1 files changed, 283 insertions, 0 deletions
diff --git a/js/src/jit-test/tests/wasm/spec/tail-call/return_call.wast.js b/js/src/jit-test/tests/wasm/spec/tail-call/return_call.wast.js
new file mode 100644
index 0000000000..2feda2e0a7
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/tail-call/return_call.wast.js
@@ -0,0 +1,283 @@
+/* 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.wast
+
+// ./test/core/return_call.wast:3
+let $0 = instantiate(`(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))))
+    )
+  )
+)`);
+
+// ./test/core/return_call.wast:80
+assert_return(() => invoke($0, `type-i32`, []), [value("i32", 306)]);
+
+// ./test/core/return_call.wast:81
+assert_return(() => invoke($0, `type-i64`, []), [value("i64", 356n)]);
+
+// ./test/core/return_call.wast:82
+assert_return(() => invoke($0, `type-f32`, []), [value("f32", 3890)]);
+
+// ./test/core/return_call.wast:83
+assert_return(() => invoke($0, `type-f64`, []), [value("f64", 3940)]);
+
+// ./test/core/return_call.wast:85
+assert_return(() => invoke($0, `type-first-i32`, []), [value("i32", 32)]);
+
+// ./test/core/return_call.wast:86
+assert_return(() => invoke($0, `type-first-i64`, []), [value("i64", 64n)]);
+
+// ./test/core/return_call.wast:87
+assert_return(() => invoke($0, `type-first-f32`, []), [value("f32", 1.32)]);
+
+// ./test/core/return_call.wast:88
+assert_return(() => invoke($0, `type-first-f64`, []), [value("f64", 1.64)]);
+
+// ./test/core/return_call.wast:90
+assert_return(() => invoke($0, `type-second-i32`, []), [value("i32", 32)]);
+
+// ./test/core/return_call.wast:91
+assert_return(() => invoke($0, `type-second-i64`, []), [value("i64", 64n)]);
+
+// ./test/core/return_call.wast:92
+assert_return(() => invoke($0, `type-second-f32`, []), [value("f32", 32)]);
+
+// ./test/core/return_call.wast:93
+assert_return(() => invoke($0, `type-second-f64`, []), [value("f64", 64.1)]);
+
+// ./test/core/return_call.wast:95
+assert_return(() => invoke($0, `fac-acc`, [0n, 1n]), [value("i64", 1n)]);
+
+// ./test/core/return_call.wast:96
+assert_return(() => invoke($0, `fac-acc`, [1n, 1n]), [value("i64", 1n)]);
+
+// ./test/core/return_call.wast:97
+assert_return(() => invoke($0, `fac-acc`, [5n, 1n]), [value("i64", 120n)]);
+
+// ./test/core/return_call.wast:98
+assert_return(() => invoke($0, `fac-acc`, [25n, 1n]), [value("i64", 7034535277573963776n)]);
+
+// ./test/core/return_call.wast:103
+assert_return(() => invoke($0, `count`, [0n]), [value("i64", 0n)]);
+
+// ./test/core/return_call.wast:104
+assert_return(() => invoke($0, `count`, [1000n]), [value("i64", 0n)]);
+
+// ./test/core/return_call.wast:105
+assert_return(() => invoke($0, `count`, [1000000n]), [value("i64", 0n)]);
+
+// ./test/core/return_call.wast:107
+assert_return(() => invoke($0, `even`, [0n]), [value("i32", 44)]);
+
+// ./test/core/return_call.wast:108
+assert_return(() => invoke($0, `even`, [1n]), [value("i32", 99)]);
+
+// ./test/core/return_call.wast:109
+assert_return(() => invoke($0, `even`, [100n]), [value("i32", 44)]);
+
+// ./test/core/return_call.wast:110
+assert_return(() => invoke($0, `even`, [77n]), [value("i32", 99)]);
+
+// ./test/core/return_call.wast:111
+assert_return(() => invoke($0, `even`, [1000000n]), [value("i32", 44)]);
+
+// ./test/core/return_call.wast:112
+assert_return(() => invoke($0, `even`, [1000001n]), [value("i32", 99)]);
+
+// ./test/core/return_call.wast:113
+assert_return(() => invoke($0, `odd`, [0n]), [value("i32", 99)]);
+
+// ./test/core/return_call.wast:114
+assert_return(() => invoke($0, `odd`, [1n]), [value("i32", 44)]);
+
+// ./test/core/return_call.wast:115
+assert_return(() => invoke($0, `odd`, [200n]), [value("i32", 99)]);
+
+// ./test/core/return_call.wast:116
+assert_return(() => invoke($0, `odd`, [77n]), [value("i32", 44)]);
+
+// ./test/core/return_call.wast:117
+assert_return(() => invoke($0, `odd`, [1000000n]), [value("i32", 99)]);
+
+// ./test/core/return_call.wast:118
+assert_return(() => invoke($0, `odd`, [999999n]), [value("i32", 44)]);
+
+// ./test/core/return_call.wast:123
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-void-vs-num (result i32) (return_call 1) (i32.const 0))
+    (func)
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/return_call.wast:130
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-num-vs-num (result i32) (return_call 1) (i32.const 0))
+    (func (result i64) (i64.const 1))
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/return_call.wast:138
+assert_invalid(
+  () => instantiate(`(module
+    (func $$arity-0-vs-1 (return_call 1))
+    (func (param i32))
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/return_call.wast:145
+assert_invalid(
+  () => instantiate(`(module
+    (func $$arity-0-vs-2 (return_call 1))
+    (func (param f64 i32))
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/return_call.wast:153
+let $1 = instantiate(`(module
+  (func $$arity-1-vs-0 (i32.const 1) (return_call 1))
+  (func)
+)`);
+
+// ./test/core/return_call.wast:158
+let $2 = instantiate(`(module
+  (func $$arity-2-vs-0 (f64.const 2) (i32.const 1) (return_call 1))
+  (func)
+)`);
+
+// ./test/core/return_call.wast:163
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-first-void-vs-num (return_call 1 (nop) (i32.const 1)))
+    (func (param i32 i32))
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/return_call.wast:170
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-second-void-vs-num (return_call 1 (i32.const 1) (nop)))
+    (func (param i32 i32))
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/return_call.wast:177
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-first-num-vs-num (return_call 1 (f64.const 1) (i32.const 1)))
+    (func (param i32 f64))
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/return_call.wast:184
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-second-num-vs-num (return_call 1 (i32.const 1) (f64.const 1)))
+    (func (param f64 i32))
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/return_call.wast:195
+assert_invalid(
+  () => instantiate(`(module (func $$unbound-func (return_call 1)))`),
+  `unknown function`,
+);
+
+// ./test/core/return_call.wast:199
+assert_invalid(
+  () => instantiate(`(module (func $$large-func (return_call 1012321300)))`),
+  `unknown function`,
+);