diff options
author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-19 00:47:55 +0000 |
---|---|---|
committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-19 00:47:55 +0000 |
commit | 26a029d407be480d791972afb5975cf62c9360a6 (patch) | |
tree | f435a8308119effd964b339f76abb83a57c29483 /js/src/jit-test/tests/wasm/spec/function-references/return_call_ref.wast.js | |
parent | Initial commit. (diff) | |
download | firefox-26a029d407be480d791972afb5975cf62c9360a6.tar.xz firefox-26a029d407be480d791972afb5975cf62c9360a6.zip |
Adding upstream version 124.0.1.upstream/124.0.1
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'js/src/jit-test/tests/wasm/spec/function-references/return_call_ref.wast.js')
-rw-r--r-- | js/src/jit-test/tests/wasm/spec/function-references/return_call_ref.wast.js | 460 |
1 files changed, 460 insertions, 0 deletions
diff --git a/js/src/jit-test/tests/wasm/spec/function-references/return_call_ref.wast.js b/js/src/jit-test/tests/wasm/spec/function-references/return_call_ref.wast.js new file mode 100644 index 0000000000..3ea51a8cb0 --- /dev/null +++ b/js/src/jit-test/tests/wasm/spec/function-references/return_call_ref.wast.js @@ -0,0 +1,460 @@ +// |jit-test| --wasm-tail-calls; skip-if: !wasmTailCallsEnabled() +/* Copyright 2021 Mozilla Foundation + * + * 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. + */ + +// ./test/core/return_call_ref.wast + +// ./test/core/return_call_ref.wast:3 +let $0 = instantiate(`(module + ;; Auxiliary definitions + (type $$proc (func)) + (type $$-i32 (func (result i32))) + (type $$-i64 (func (result i64))) + (type $$-f32 (func (result f32))) + (type $$-f64 (func (result f64))) + + (type $$i32-i32 (func (param i32) (result i32))) + (type $$i64-i64 (func (param i64) (result i64))) + (type $$f32-f32 (func (param f32) (result f32))) + (type $$f64-f64 (func (param f64) (result f64))) + + (type $$f32-i32 (func (param f32 i32) (result i32))) + (type $$i32-i64 (func (param i32 i64) (result i64))) + (type $$f64-f32 (func (param f64 f32) (result f32))) + (type $$i64-f64 (func (param i64 f64) (result f64))) + + (type $$i64i64-i64 (func (param i64 i64) (result i64))) + + (func $$const-i32 (result i32) (i32.const 0x132)) + (func $$const-i64 (result i64) (i64.const 0x164)) + (func $$const-f32 (result f32) (f32.const 0xf32)) + (func $$const-f64 (result f64) (f64.const 0xf64)) + + (func $$id-i32 (param i32) (result i32) (local.get 0)) + (func $$id-i64 (param i64) (result i64) (local.get 0)) + (func $$id-f32 (param f32) (result f32) (local.get 0)) + (func $$id-f64 (param f64) (result f64) (local.get 0)) + + (func $$f32-i32 (param f32 i32) (result i32) (local.get 1)) + (func $$i32-i64 (param i32 i64) (result i64) (local.get 1)) + (func $$f64-f32 (param f64 f32) (result f32) (local.get 1)) + (func $$i64-f64 (param i64 f64) (result f64) (local.get 1)) + + (global $$const-i32 (ref $$-i32) (ref.func $$const-i32)) + (global $$const-i64 (ref $$-i64) (ref.func $$const-i64)) + (global $$const-f32 (ref $$-f32) (ref.func $$const-f32)) + (global $$const-f64 (ref $$-f64) (ref.func $$const-f64)) + + (global $$id-i32 (ref $$i32-i32) (ref.func $$id-i32)) + (global $$id-i64 (ref $$i64-i64) (ref.func $$id-i64)) + (global $$id-f32 (ref $$f32-f32) (ref.func $$id-f32)) + (global $$id-f64 (ref $$f64-f64) (ref.func $$id-f64)) + + (global $$f32-i32 (ref $$f32-i32) (ref.func $$f32-i32)) + (global $$i32-i64 (ref $$i32-i64) (ref.func $$i32-i64)) + (global $$f64-f32 (ref $$f64-f32) (ref.func $$f64-f32)) + (global $$i64-f64 (ref $$i64-f64) (ref.func $$i64-f64)) + + (elem declare func + $$const-i32 $$const-i64 $$const-f32 $$const-f64 + $$id-i32 $$id-i64 $$id-f32 $$id-f64 + $$f32-i32 $$i32-i64 $$f64-f32 $$i64-f64 + ) + + ;; Typing + + (func (export "type-i32") (result i32) + (return_call_ref $$-i32 (global.get $$const-i32)) + ) + (func (export "type-i64") (result i64) + (return_call_ref $$-i64 (global.get $$const-i64)) + ) + (func (export "type-f32") (result f32) + (return_call_ref $$-f32 (global.get $$const-f32)) + ) + (func (export "type-f64") (result f64) + (return_call_ref $$-f64 (global.get $$const-f64)) + ) + + (func (export "type-first-i32") (result i32) + (return_call_ref $$i32-i32 (i32.const 32) (global.get $$id-i32)) + ) + (func (export "type-first-i64") (result i64) + (return_call_ref $$i64-i64 (i64.const 64) (global.get $$id-i64)) + ) + (func (export "type-first-f32") (result f32) + (return_call_ref $$f32-f32 (f32.const 1.32) (global.get $$id-f32)) + ) + (func (export "type-first-f64") (result f64) + (return_call_ref $$f64-f64 (f64.const 1.64) (global.get $$id-f64)) + ) + + (func (export "type-second-i32") (result i32) + (return_call_ref $$f32-i32 (f32.const 32.1) (i32.const 32) (global.get $$f32-i32)) + ) + (func (export "type-second-i64") (result i64) + (return_call_ref $$i32-i64 (i32.const 32) (i64.const 64) (global.get $$i32-i64)) + ) + (func (export "type-second-f32") (result f32) + (return_call_ref $$f64-f32 (f64.const 64) (f32.const 32) (global.get $$f64-f32)) + ) + (func (export "type-second-f64") (result f64) + (return_call_ref $$i64-f64 (i64.const 64) (f64.const 64.1) (global.get $$i64-f64)) + ) + + ;; Null + + (func (export "null") + (return_call_ref $$proc (ref.null $$proc)) + ) + + ;; Recursion + + (global $$fac-acc (ref $$i64i64-i64) (ref.func $$fac-acc)) + + (elem declare func $$fac-acc) + (func $$fac-acc (export "fac-acc") (param i64 i64) (result i64) + (if (result i64) (i64.eqz (local.get 0)) + (then (local.get 1)) + (else + (return_call_ref $$i64i64-i64 + (i64.sub (local.get 0) (i64.const 1)) + (i64.mul (local.get 0) (local.get 1)) + (global.get $$fac-acc) + ) + ) + ) + ) + + (global $$count (ref $$i64-i64) (ref.func $$count)) + + (elem declare func $$count) + (func $$count (export "count") (param i64) (result i64) + (if (result i64) (i64.eqz (local.get 0)) + (then (local.get 0)) + (else + (return_call_ref $$i64-i64 + (i64.sub (local.get 0) (i64.const 1)) + (global.get $$count) + ) + ) + ) + ) + + (global $$even (ref $$i64-i64) (ref.func $$even)) + (global $$odd (ref $$i64-i64) (ref.func $$odd)) + + (elem declare func $$even) + (func $$even (export "even") (param i64) (result i64) + (if (result i64) (i64.eqz (local.get 0)) + (then (i64.const 44)) + (else + (return_call_ref $$i64-i64 + (i64.sub (local.get 0) (i64.const 1)) + (global.get $$odd) + ) + ) + ) + ) + (elem declare func $$odd) + (func $$odd (export "odd") (param i64) (result i64) + (if (result i64) (i64.eqz (local.get 0)) + (then (i64.const 99)) + (else + (return_call_ref $$i64-i64 + (i64.sub (local.get 0) (i64.const 1)) + (global.get $$even) + ) + ) + ) + ) +)`); + +// ./test/core/return_call_ref.wast:168 +assert_return(() => invoke($0, `type-i32`, []), [value("i32", 306)]); + +// ./test/core/return_call_ref.wast:169 +assert_return(() => invoke($0, `type-i64`, []), [value("i64", 356n)]); + +// ./test/core/return_call_ref.wast:170 +assert_return(() => invoke($0, `type-f32`, []), [value("f32", 3890)]); + +// ./test/core/return_call_ref.wast:171 +assert_return(() => invoke($0, `type-f64`, []), [value("f64", 3940)]); + +// ./test/core/return_call_ref.wast:173 +assert_return(() => invoke($0, `type-first-i32`, []), [value("i32", 32)]); + +// ./test/core/return_call_ref.wast:174 +assert_return(() => invoke($0, `type-first-i64`, []), [value("i64", 64n)]); + +// ./test/core/return_call_ref.wast:175 +assert_return(() => invoke($0, `type-first-f32`, []), [value("f32", 1.32)]); + +// ./test/core/return_call_ref.wast:176 +assert_return(() => invoke($0, `type-first-f64`, []), [value("f64", 1.64)]); + +// ./test/core/return_call_ref.wast:178 +assert_return(() => invoke($0, `type-second-i32`, []), [value("i32", 32)]); + +// ./test/core/return_call_ref.wast:179 +assert_return(() => invoke($0, `type-second-i64`, []), [value("i64", 64n)]); + +// ./test/core/return_call_ref.wast:180 +assert_return(() => invoke($0, `type-second-f32`, []), [value("f32", 32)]); + +// ./test/core/return_call_ref.wast:181 +assert_return(() => invoke($0, `type-second-f64`, []), [value("f64", 64.1)]); + +// ./test/core/return_call_ref.wast:183 +assert_trap(() => invoke($0, `null`, []), `null function`); + +// ./test/core/return_call_ref.wast:185 +assert_return(() => invoke($0, `fac-acc`, [0n, 1n]), [value("i64", 1n)]); + +// ./test/core/return_call_ref.wast:186 +assert_return(() => invoke($0, `fac-acc`, [1n, 1n]), [value("i64", 1n)]); + +// ./test/core/return_call_ref.wast:187 +assert_return(() => invoke($0, `fac-acc`, [5n, 1n]), [value("i64", 120n)]); + +// ./test/core/return_call_ref.wast:188 +assert_return(() => invoke($0, `fac-acc`, [25n, 1n]), [value("i64", 7034535277573963776n)]); + +// ./test/core/return_call_ref.wast:193 +assert_return(() => invoke($0, `count`, [0n]), [value("i64", 0n)]); + +// ./test/core/return_call_ref.wast:194 +assert_return(() => invoke($0, `count`, [1000n]), [value("i64", 0n)]); + +// ./test/core/return_call_ref.wast:195 +assert_return(() => invoke($0, `count`, [1000000n]), [value("i64", 0n)]); + +// ./test/core/return_call_ref.wast:197 +assert_return(() => invoke($0, `even`, [0n]), [value("i64", 44n)]); + +// ./test/core/return_call_ref.wast:198 +assert_return(() => invoke($0, `even`, [1n]), [value("i64", 99n)]); + +// ./test/core/return_call_ref.wast:199 +assert_return(() => invoke($0, `even`, [100n]), [value("i64", 44n)]); + +// ./test/core/return_call_ref.wast:200 +assert_return(() => invoke($0, `even`, [77n]), [value("i64", 99n)]); + +// ./test/core/return_call_ref.wast:201 +assert_return(() => invoke($0, `even`, [1000000n]), [value("i64", 44n)]); + +// ./test/core/return_call_ref.wast:202 +assert_return(() => invoke($0, `even`, [1000001n]), [value("i64", 99n)]); + +// ./test/core/return_call_ref.wast:203 +assert_return(() => invoke($0, `odd`, [0n]), [value("i64", 99n)]); + +// ./test/core/return_call_ref.wast:204 +assert_return(() => invoke($0, `odd`, [1n]), [value("i64", 44n)]); + +// ./test/core/return_call_ref.wast:205 +assert_return(() => invoke($0, `odd`, [200n]), [value("i64", 99n)]); + +// ./test/core/return_call_ref.wast:206 +assert_return(() => invoke($0, `odd`, [77n]), [value("i64", 44n)]); + +// ./test/core/return_call_ref.wast:207 +assert_return(() => invoke($0, `odd`, [1000000n]), [value("i64", 99n)]); + +// ./test/core/return_call_ref.wast:208 +assert_return(() => invoke($0, `odd`, [999999n]), [value("i64", 44n)]); + +// ./test/core/return_call_ref.wast:213 +let $1 = instantiate(`(module + (type $$t (func)) + (type $$t1 (func (result (ref $$t)))) + (type $$t2 (func (result (ref null $$t)))) + (type $$t3 (func (result (ref func)))) + (type $$t4 (func (result (ref null func)))) + (elem declare func $$f11 $$f22 $$f33 $$f44) + (func $$f11 (result (ref $$t)) (return_call_ref $$t1 (ref.func $$f11))) + (func $$f21 (result (ref null $$t)) (return_call_ref $$t1 (ref.func $$f11))) + (func $$f22 (result (ref null $$t)) (return_call_ref $$t2 (ref.func $$f22))) + (func $$f31 (result (ref func)) (return_call_ref $$t1 (ref.func $$f11))) + (func $$f33 (result (ref func)) (return_call_ref $$t3 (ref.func $$f33))) + (func $$f41 (result (ref null func)) (return_call_ref $$t1 (ref.func $$f11))) + (func $$f42 (result (ref null func)) (return_call_ref $$t2 (ref.func $$f22))) + (func $$f43 (result (ref null func)) (return_call_ref $$t3 (ref.func $$f33))) + (func $$f44 (result (ref null func)) (return_call_ref $$t4 (ref.func $$f44))) +)`); + +// ./test/core/return_call_ref.wast:231 +assert_invalid( + () => instantiate(`(module + (type $$t (func)) + (type $$t2 (func (result (ref null $$t)))) + (elem declare func $$f22) + (func $$f12 (result (ref $$t)) (return_call_ref $$t2 (ref.func $$f22))) + (func $$f22 (result (ref null $$t)) (return_call_ref $$t2 (ref.func $$f22))) + )`), + `type mismatch`, +); + +// ./test/core/return_call_ref.wast:242 +assert_invalid( + () => instantiate(`(module + (type $$t (func)) + (type $$t3 (func (result (ref func)))) + (elem declare func $$f33) + (func $$f13 (result (ref $$t)) (return_call_ref $$t3 (ref.func $$f33))) + (func $$f33 (result (ref func)) (return_call_ref $$t3 (ref.func $$f33))) + )`), + `type mismatch`, +); + +// ./test/core/return_call_ref.wast:253 +assert_invalid( + () => instantiate(`(module + (type $$t (func)) + (type $$t4 (func (result (ref null func)))) + (elem declare func $$f44) + (func $$f14 (result (ref $$t)) (return_call_ref $$t4 (ref.func $$f44))) + (func $$f44 (result (ref null func)) (return_call_ref $$t4 (ref.func $$f44))) + )`), + `type mismatch`, +); + +// ./test/core/return_call_ref.wast:264 +assert_invalid( + () => instantiate(`(module + (type $$t (func)) + (type $$t3 (func (result (ref func)))) + (elem declare func $$f33) + (func $$f23 (result (ref null $$t)) (return_call_ref $$t3 (ref.func $$f33))) + (func $$f33 (result (ref func)) (return_call_ref $$t3 (ref.func $$f33))) + )`), + `type mismatch`, +); + +// ./test/core/return_call_ref.wast:275 +assert_invalid( + () => instantiate(`(module + (type $$t (func)) + (type $$t4 (func (result (ref null func)))) + (elem declare func $$f44) + (func $$f24 (result (ref null $$t)) (return_call_ref $$t4 (ref.func $$f44))) + (func $$f44 (result (ref null func)) (return_call_ref $$t4 (ref.func $$f44))) + )`), + `type mismatch`, +); + +// ./test/core/return_call_ref.wast:286 +assert_invalid( + () => instantiate(`(module + (type $$t4 (func (result (ref null func)))) + (elem declare func $$f44) + (func $$f34 (result (ref func)) (return_call_ref $$t4 (ref.func $$f44))) + (func $$f44 (result (ref null func)) (return_call_ref $$t4 (ref.func $$f44))) + )`), + `type mismatch`, +); + +// ./test/core/return_call_ref.wast:299 +let $2 = instantiate(`(module + (type $$t (func (result i32))) + (func (export "unreachable") (result i32) + (unreachable) + (return_call_ref $$t) + ) +)`); + +// ./test/core/return_call_ref.wast:306 +assert_trap(() => invoke($2, `unreachable`, []), `unreachable`); + +// ./test/core/return_call_ref.wast:308 +let $3 = instantiate(`(module + (elem declare func $$f) + (type $$t (func (param i32) (result i32))) + (func $$f (param i32) (result i32) (local.get 0)) + + (func (export "unreachable") (result i32) + (unreachable) + (ref.func $$f) + (return_call_ref $$t) + ) +)`); + +// ./test/core/return_call_ref.wast:319 +assert_trap(() => invoke($3, `unreachable`, []), `unreachable`); + +// ./test/core/return_call_ref.wast:321 +let $4 = instantiate(`(module + (elem declare func $$f) + (type $$t (func (param i32) (result i32))) + (func $$f (param i32) (result i32) (local.get 0)) + + (func (export "unreachable") (result i32) + (unreachable) + (i32.const 0) + (ref.func $$f) + (return_call_ref $$t) + (i32.const 0) + ) +)`); + +// ./test/core/return_call_ref.wast:334 +assert_trap(() => invoke($4, `unreachable`, []), `unreachable`); + +// ./test/core/return_call_ref.wast:336 +assert_invalid( + () => instantiate(`(module + (elem declare func $$f) + (type $$t (func (param i32) (result i32))) + (func $$f (param i32) (result i32) (local.get 0)) + + (func (export "unreachable") (result i32) + (unreachable) + (i64.const 0) + (ref.func $$f) + (return_call_ref $$t) + ) + )`), + `type mismatch`, +); + +// ./test/core/return_call_ref.wast:352 +assert_invalid( + () => instantiate(`(module + (elem declare func $$f) + (type $$t (func (param i32) (result i32))) + (func $$f (param i32) (result i32) (local.get 0)) + + (func (export "unreachable") (result i32) + (unreachable) + (ref.func $$f) + (return_call_ref $$t) + (i64.const 0) + ) + )`), + `type mismatch`, +); + +// ./test/core/return_call_ref.wast:368 +assert_invalid( + () => instantiate(`(module + (type $$t (func)) + (func $$f (param $$r externref) + (return_call_ref $$t (local.get $$r)) + ) + )`), + `type mismatch`, +); |