Adding upstream version 1:115.7.0.upstream/1%115.7.0upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

77 files changed, 8581 insertions, 0 deletions

diff --git a/js/src/jit-test/README b/js/src/jit-test/README
new file mode 100644
index 0000000000..b8b01af4b5
--- /dev/null
+++ b/js/src/jit-test/README
@@ -0,0 +1,107 @@
+JS Internal Test Suite
+
+* PURPOSE
+
+This is a test suite primarily for testing the SpiderMonkey JIT, GC, and any
+other internal mechanisms that are not visible to test262. All tests are run in
+the JS shell.
+
+In the future, we intend to migrate the "non262" jstests over to this framework.
+
+* CONTINUOUS INTEGRATION
+
+In CI, these tests will be run as part of the "SM(...)" set of jobs. They will
+also be packaged up and then run via mozharness as separate test jobs on some
+platforms. These will appear on treeherder as jobs starting with "Jit", eg
+"Jit", "Jit3", "Jit-1proc3", etc.
+
+Unlike jstests, we do not run jit-tests in the browser. All tests may assume
+they are running in the JS shell environment.
+
+* REQUIREMENTS
+
+Python 3.6. This is already a standard requirement for building our tree.
+
+* RUNNING THE TESTS
+
+Basic usage:
+
+    ./mach jit-test
+
+from the top of the checkout. Directly invoking
+
+    python jit_test.py <path-to-js-shell>
+
+will also work. The progress bar shows [#tests passed, #tests failed, #tests
+run] at the left. If all tests pass, the output is 'PASSED ALL'. The test suite
+can be interrupted at any time with Ctrl+C and partial results will be printed.
+
+To run only the basic tests, not including the slow tests:
+
+    ./mach jit-test <path-to-js-shell> basic
+
+For more options:
+
+    ./mach jit-test -- -h
+
+or
+
+    python jit_test.py -h
+
+for the jit-test harness options, or
+
+    ./mach jit-test -h
+
+for the mach driver's options (eg --cgc).
+
+* CREATING NEW TESTS
+
+Simply create a JS file under the 'tests/' directory. Most tests should go in
+'tests/basic/'.
+
+All tests are run with 'lib/prologue.js' included first on the command line. The
+command line also creates a global variable 'libdir' that is set to the path
+of the 'lib' directory. To include a file 'foo.js' from the lib directory in a
+test case:
+
+    load(libdir + 'foo.js')
+
+* TEST METALINES
+
+The first line of a test case can contain a special comment controlling how the
+test is run. For example:
+
+    // |jit-test| allow-oom; --no-threads
+
+The general format in EBNF is:
+
+    metaline  ::= cookie { item ";" }
+    cookie    ::= "|jit-test|"
+    item      ::= flag | attribute
+
+    flag      ::= "slow" | "allow-oom" | "valgrind" | "tz-pacific" | "debug" |
+                  "--" switch
+
+    attribute ::= name ":" value
+    name      ::= "error" | "exitstatus"
+    value     ::= <string>
+    switch    ::= <string>
+
+The metaline may appear anywhere in the first line of the file: this allows it
+to be placed inside any kind of comment.
+
+The meaning of the items:
+
+    slow         Test runs slowly. Do not run if the --no-slow option is given.
+    allow-oom    If the test runs out of memory, it counts as passing.
+    valgrind     Run test under valgrind.
+    tz-pacific   Always run test with the Pacific time zone (TZ=PST8PDT).
+
+    error        The test should be considered to pass iff it throws the
+                 given JS exception.
+    exitstatus   The test should exit with the given status value (an integer).
+
+    debug        Run js with -d, whether --jitflags says to or not
+    --SWITCH     Pass --SWITCH through to js
+
+* END
diff --git a/js/src/jit-test/etc/generate-lookupswitch-tests.js b/js/src/jit-test/etc/generate-lookupswitch-tests.js
new file mode 100644
index 0000000000..2fd2b73d1c
--- /dev/null
+++ b/js/src/jit-test/etc/generate-lookupswitch-tests.js
@@ -0,0 +1,365 @@
+
+/**
+ * A test case spec is an array of objects of the following kind:
+ *  { 'match': Num|Str|Null,
+ *    'body': Num|Str|Null,
+ *    'fallthrough': Boolean }
+ *
+ * If the 'match' is null, then it represents a 'default:'
+ * If the 'match' is not null, it represents a 'case X:' where X is the value.
+ * If the 'body' is null, then it means that the case body is empty.  Otherwise,
+ * it means that the case body is a single 'arr.push(V);' where "arr" is an input
+ * array to the function containing the switch statement, and V is the value.
+ * If 'fallthrough' is false, then the body is terminated with a break, otherwise
+ * it is not.
+ *
+ * So a spec: [{'match':3, 'body':null, 'fallthrough':false}, {'match':null, 'body':"foo", 'fallthrough':true}]
+ * Represents a switch function:
+ *  function(x, arr) {
+ *      switch(x) {
+ *      case 3:
+ *          break;
+ *      default:
+ *          arr.push('foo');
+ *      }
+ *  }
+ *
+ * GenerateSpecPermutes generates a bunch of relevant specs, using the given case match-values,
+ * and appends them to result the array passed into it.
+ *
+ * InterpretSwitch takes a spec, a value, and a result array, and behaves as if the switch specified
+ * by the spec had been called on the value and the result array.
+ *
+ * VerifySwitchSpec is there but not used in the code.  I was using it while testing the test case
+ * generator.  It verifies that a switch spec is sane.
+ *
+ * RunSpec uses eval to run the test directly.  It's not used currently.
+ *
+ * GenerateSwitchCode generates a string of the form "function NAME(x, arg) { .... }" which
+ * contains the switch modeled by its input spec.
+ *
+ * RunTest is there to be used from within the generated script.  Its code is dumped out
+ * to the generated script text, and invoked there.
+ *
+ * Hope all of this makes some sort of sense.
+ *  -kannan
+ */
+
+/** HELPERS **/
+
+function ASSERT(cond, msg) { assertEq(cond, true, msg); }
+
+function IsUndef(x) { return typeof(x) == 'undefined'; }
+function IsNull(x) { return typeof(x) == 'object' && x == null; }
+function IsNum(x) { return typeof(x) == 'number'; }
+function IsStr(x) { return typeof(x) == 'string'; }
+function IsBool(x) { return typeof(x) == 'boolean'; }
+
+function Repr(x) {
+    ASSERT(IsNum(x) || IsStr(x), "Repr");
+    if(IsNum(x)) { return ""+x; }
+    else { return "'"+x+"'"; }
+}
+
+function RandBool() { return Math.random() >= 0.5; }
+function RandInt(max) {
+    if(IsUndef(max)) { max = 0x7fffffff; }
+    return (Math.random() * max)|0;
+}
+
+var CHARS = "abcdefghijklmnopqrstuvywxyzABCDEFGHIJKLMNOPQRSTUVYWXYZ0123456789~!@#$%^&*()-_=+{}[]";
+function RandStr() {
+    var arr = [];
+    var len = Math.floor(Math.random() * 10) + 1;
+    for(var i = 0; i < len; i++) {
+        var c = Math.floor(Math.random() * CHARS.length);
+        arr.push(CHARS[c]);
+    }
+    return arr.join('');
+}
+
+function RandVal() { return RandBool() ? RandInt() : RandStr(); }
+
+/**
+ * Compare two arrays and ensure they are equal.
+ */
+function ArraysEqual(arr1, arr2) {
+    ASSERT(arr1.length == arr2.length, "Lengths not equal");
+    for(var i = 0; i < arr1.length; i++) {
+        ASSERT(typeof(arr1[i]) == typeof(arr2[i]), "Types not equal for position " + i);
+        ASSERT(arr1[i] == arr2[i], "Values not equal for position " + i);
+    }
+}
+
+function VerifySwitchSpec(spec) {
+    var foundDefault = undefined;
+    for(var i = 0; i < spec.length; i++) {
+        var caseSpec = spec[i],
+            match = caseSpec.match,
+            body = caseSpec.body,
+            fallthrough = caseSpec.fallthrough;
+        ASSERT(IsNum(match) || IsStr(match) || IsNull(match), "Invalid case match for " + i);
+        ASSERT(IsNum(body) || IsStr(body) || IsNull(body), "Invalid case body for " + i);
+        ASSERT(IsBool(fallthrough), "Invalid fallthrough for " + i);
+
+        if(IsNull(match)) {
+            ASSERT(IsUndef(foundDefault), "Duplicate default found at " + i);
+            foundDefault = i;
+        }
+    }
+}
+
+/**
+ * Do a manual interpretation of a particular spec, given an input
+ * and outputting to an output array.
+ */
+function InterpretSwitch(spec, input, outputArray) {
+    var foundMatch = undefined, foundDefault = undefined;
+    // Go through cases, trying to find a matching clause.
+    for(var i = 0; i < spec.length; i++) {
+        var caseSpec = spec[i], match = caseSpec.match;
+
+        if(IsNull(match)) {
+            foundDefault = i;
+            continue;
+        } else if(match === input) {
+            foundMatch = i;
+            break;
+        }
+    }
+    // Select either matching clause or default.
+    var matchI = IsNum(foundMatch) ? foundMatch : foundDefault;
+
+    // If match or default was found, interpret body from that point on.
+    if(IsNum(matchI)) {
+        for(var i = matchI; i < spec.length; i++) {
+            var caseSpec = spec[i],
+                match = caseSpec.match,
+                body = caseSpec.body,
+                fallthrough = caseSpec.fallthrough;
+            if(!IsNull(body)) { outputArray.push(body); }
+            if(!fallthrough) { break; }
+        }
+    }
+}
+
+/**
+ * Generate the code string for a javascript function containing the
+ * switch specified by the spec, in pure JS syntax.
+ */
+function GenerateSwitchCode(spec, name) {
+    var lines = [];
+    if(!name) { name = ""; }
+
+    lines.push("function "+name+"(x, arr) {");
+    lines.push("    switch(x) {");
+    for(var i = 0; i < spec.length; i++) {
+        var caseSpec = spec[i],
+            match = caseSpec.match,
+            body = caseSpec.body,
+            fallthrough = caseSpec.fallthrough;
+
+        if(IsNull(match))   { lines.push("    default:"); }
+        else                { lines.push("    case "+Repr(match)+":"); }
+
+        if(!IsNull(body))   { lines.push("        arr.push("+Repr(body)+");"); }
+        if(!fallthrough)    { lines.push("        break;"); }
+    }
+    lines.push("    }");
+    lines.push("}");
+    return lines.join("\n");
+}
+
+/**
+ * Generates all possible specs for a given set of case match values.
+ */
+function GenerateSpecPermutes(matchVals, resultArray) {
+    ASSERT((0 < matchVals.length) && (matchVals.length <= 5), "Invalid matchVals");
+    var maxPermuteBody = (1 << matchVals.length) - 1;
+    for(var bod_pm = 0; bod_pm <= maxPermuteBody; bod_pm++) {
+        var maxPermuteFallthrough = (1 << matchVals.length) - 1;
+
+        for(var ft_pm = 0; ft_pm <= maxPermuteFallthrough; ft_pm++) {
+            // use bod_m and ft_pm to decide the placement of null vs value bodies,
+            // and the placement of fallthroughs vs breaks.
+            // Empty bodies always fall through, so fallthrough bitmask 1s must be
+            // a subset of the body bitmask 1s.
+            if((bod_pm | ft_pm) != bod_pm) {
+                continue;
+            }
+
+            var spec = [];
+            for(var k = 0; k < matchVals.length; k++) {
+                var match = matchVals[k];
+                var body = ((bod_pm & (1 << k)) > 0) ? null : RandVal();
+                var fallthrough = ((ft_pm & (1 << k)) > 0) ? true : false;
+                var caseSpec = {'match':match, 'body':body, 'fallthrough':fallthrough};
+                spec.push(caseSpec);
+            }
+
+            // Variant specs for following cases:
+
+            // Default with empty body, fallthrough
+            GenerateDefaultPermutes(spec, null, true, resultArray);
+            // Default with nonempty body, fallthrough
+            GenerateDefaultPermutes(spec, RandVal(), true, resultArray);
+            // Default with nonempty body, break
+            GenerateDefaultPermutes(spec, RandVal(), false, resultArray);
+        }
+    }
+}
+function GenerateDefaultPermutes(spec, body, fallthrough, resultArray) {
+    if(spec.length <= 2) {
+        for(var i = 0; i <= spec.length; i++) {
+            var copy = CopySpec(spec);
+            if(IsNull(body)) {
+                copy.splice(i,0,{'match':null, 'body':null, 'fallthrough':true});
+            } else {
+                copy.splice(i,0,{'match':null, 'body':body, 'fallthrough':fallthrough});
+            }
+            resultArray.push(copy);
+        }
+    } else {
+        var posns = [0, Math.floor(spec.length / 2), spec.length];
+        posns.forEach(function (i) {
+            var copy = CopySpec(spec);
+            if(IsNull(body)) {
+                copy.splice(i,0,{'match':null, 'body':null, 'fallthrough':true});
+            } else {
+                copy.splice(i,0,{'match':null, 'body':body, 'fallthrough':fallthrough});
+            }
+            resultArray.push(copy);
+        });
+    }
+}
+function CopySpec(spec) {
+    var newSpec = [];
+    for(var i = 0; i < spec.length; i++) {
+        var caseSpec = spec[i];
+        newSpec.push({'match':caseSpec.match,
+                      'body':caseSpec.body,
+                      'fallthrough':caseSpec.fallthrough});
+    }
+    return newSpec;
+}
+
+
+function RunSpec(spec, matchVals) {
+    var code = GenerateSwitchCode(spec);
+
+    // Generate roughly 200 inputs for the test case spec, exercising
+    // every match value, as well as 3 randomly generated values for every
+    // iteration of the match values.
+    var inputs = [];
+    while(inputs.length < 500) {
+        for(var i = 0; i < matchVals.length; i++) { inputs.push(matchVals[i]); }
+        for(var i = 0; i < 3; i++) { inputs.push(RandVal()); }
+    }
+
+    // Interpret the lookupswitch with the inputs.
+    var interpResults = [];
+    for(var i = 0; i < inputs.length; i++) {
+        InterpretSwitch(spec, inputs[i], interpResults);
+    }
+
+    // Run compiled lookupswitch with the inputs.
+    var fn = eval("_ = " + code);
+    print("Running spec: " + code);
+    var compileResults = RunCompiled(fn, inputs);
+    print("Done Running spec");
+
+    // Verify that they produce the same output.
+    ASSERT(interpResults.length == compileResults.length, "Length mismatch");
+    for(var i = 0; i < interpResults.length; i++) {
+        ASSERT(interpResults[i] == compileResults[i], "Value mismatch");
+    }
+}
+function RunCompiled(fn, inputs) {
+    var results = [];
+    var len = inputs.length;
+    for(var i = 0; i < len; i++) { fn(inputs[i], results); }
+    return results;
+}
+
+function PrintSpec(spec, inputs, fname) {
+    var code = GenerateSwitchCode(spec, fname);
+    var input_s = fname + ".INPUTS = [" + inputs.map(Repr).join(', ') + "];";
+    var spec_s = fname + ".SPEC = " + JSON.stringify(spec) + ";";
+    print(code + "\n" + input_s + "\n" + spec_s);
+}
+
+function RunTest(test) {
+    // Exercise every test case as well as one case which won't match with any of the
+    // ("But what if it randomly generates a string case match whose value is
+    //   UNMATCHED_CASE?!", you ask incredulously.  Well, RandStr limits itself to 11 chars.
+    //   So there.)
+    var inputs = test.INPUTS;
+    inputs.push("UNMATCHED_CASE");
+    var spec = test.SPEC;
+
+    var results1 = [];
+    for(var i = 0; i < 80; i++) {
+        for(var j = 0; j < inputs.length; j++) {
+            test(inputs[j], results1);
+        }
+    }
+
+    var results2 = [];
+    for(var i = 0; i < 80; i++) {
+        for(var j = 0; j < inputs.length; j++) {
+            InterpretSwitch(spec, inputs[j], results2);
+        }
+    }
+    ArraysEqual(results1, results2);
+}
+
+// NOTES:
+//  * RunTest is used within the generated test script.
+//  * InterpretSwitch is printed out into the generated test script.
+
+print("/////////////////////////////////////////");
+print("// This is a generated file!");
+print("// See jit-tests/etc/generate-lookupswitch-tests.js for the code");
+print("// that generated this code!");
+print("/////////////////////////////////////////");
+print("");
+print("/////////////////////////////////////////");
+print("// PRELUDE                             //");
+print("/////////////////////////////////////////");
+print("");
+print("// Avoid eager compilation of the global-scope.");
+print("try{} catch (x) {};");
+print("");
+print(ASSERT);
+print(IsNull);
+print(IsNum);
+print(ArraysEqual);
+print(InterpretSwitch);
+print(RunTest);
+print("");
+print("/////////////////////////////////////////");
+print("// TEST CASES                          //");
+print("/////////////////////////////////////////");
+print("");
+print("var TESTS = [];");
+var MATCH_SETS = [["foo", "bar", "zing"]];
+var count = 0;
+for(var i = 0; i < MATCH_SETS.length; i++) {
+    var matchSet = MATCH_SETS[i];
+    var specs = [];
+    GenerateSpecPermutes(matchSet, specs);
+    for(var j = 0; j < specs.length; j++) {
+        count++;
+        PrintSpec(specs[j], matchSet.slice(), 'test_'+count);
+        print("TESTS.push(test_"+count+");\n");
+    }
+}
+
+print("");
+print("/////////////////////////////////////////");
+print("// RUNNER                              //");
+print("/////////////////////////////////////////");
+print("");
+print("for(var i = 0; i < TESTS.length; i++) {");
+print("  RunTest(TESTS[i]);");
+print("}");
diff --git a/js/src/jit-test/etc/generate-nosuchproperty-tests.js b/js/src/jit-test/etc/generate-nosuchproperty-tests.js
new file mode 100644
index 0000000000..a0bb3e47db
--- /dev/null
+++ b/js/src/jit-test/etc/generate-nosuchproperty-tests.js
@@ -0,0 +1,78 @@
+
+// This code generates the test cases jit-test/tests/baseline/no-such-property-getprop.js
+//
+// In particular, it generates the testChain_<N>_<I>() and runChain_<N>_<I>() functions
+// at the tail of the file.
+
+var TEST_CASE_FUNCS =  [];
+function runChain_NNNN_DDDD(obj) {
+    var sum = 0;
+    for (var i = 0; i < 100; i++)
+        sum += obj.foo;
+    return sum;
+}
+function testChain_NNNN_DDDD() {
+    var obj = createTower(NNNN);
+    assertEq(runChain_NNNN_DDDD(obj), NaN);
+    updateChain(obj, DDDD, 'foo', 9);
+    assertEq(runChain_NNNN_DDDD(obj), 900);
+}
+function generateTestCase(n, d) {
+    var runFuncName = "runChain_" + n + "_" + d;
+    var testFuncName = "testChain_" + n + "_" + d;
+    TEST_CASE_FUNCS.push(testFuncName);
+
+    print("//// Test chain of length " + n + " with late-property-addition at depth " + d);
+    print(String(runChain_NNNN_DDDD).replace(/NNNN/g, ''+n).replace(/DDDD/g, ''+d));
+    print(String(testChain_NNNN_DDDD).replace(/NNNN/g, ''+n).replace(/DDDD/g, ''+d));
+    print("");
+}
+
+// Helper function to create an object with a proto-chain of length N.
+function createTower(n) {
+    var result = Object.create(null);
+    for (var i = 0; i < n; i++)
+        result = Object.create(result);
+    return result;
+}
+
+function updateChain(obj, depth, prop, value) {
+    // Walk down the proto chain |depth| iterations and set |prop| to |value|.
+    var cur = obj;
+    for (var i = 0; i < depth; i++)
+        cur = Object.getPrototypeOf(cur);
+
+    var desc = {value:value, writable:true, configurable:true, enumerable:true};
+    Object.defineProperty(cur, prop, desc);
+}
+
+print("/////////////////////////////////////////");
+print("// This is a generated file!");
+print("// See jit-tests/etc/generate-nosuchproperty-tests.js for the code");
+print("// that generated this code!");
+print("/////////////////////////////////////////");
+print("");
+print("/////////////////////////////////////////");
+print("// PRELUDE                             //");
+print("/////////////////////////////////////////");
+print("");
+print(createTower);
+print(updateChain);
+print("");
+print("/////////////////////////////////////////");
+print("// TEST CASES                          //");
+print("/////////////////////////////////////////");
+print("");
+for (var n = 0; n <= 10; n++) {
+    for (var d = 0; d <= n; d++) {
+        generateTestCase(n, d);
+    }
+}
+
+print("");
+print("/////////////////////////////////////////");
+print("// RUNNER                              //");
+print("/////////////////////////////////////////");
+print("");
+for (var i = 0; i < TEST_CASE_FUNCS.length; i++)
+    print(TEST_CASE_FUNCS[i] + "();");
diff --git a/js/src/jit-test/etc/wasm/Makefile b/js/src/jit-test/etc/wasm/Makefile
new file mode 100644
index 0000000000..c659a7000e
--- /dev/null
+++ b/js/src/jit-test/etc/wasm/Makefile
@@ -0,0 +1,10 @@
+.PHONY: update
+
+warning = '\# Wasm Spec Tests\n\nThese tests are autogenerated using a tool, do not edit.\n\nSee `jit-test/etc/wasm/` for more information.'
+
+update:
+	(cd ./generate-spectests && RUST_BACKTRACE=1 RUST_LOG=info cargo run --release)
+	rm -r ../../tests/wasm/spec
+	cp -R generate-spectests/tests/js ../../tests/wasm/spec
+	echo $(warning) > ../../tests/wasm/spec/README.md
+	[ -f ./spec-tests.patch ] && (cd ../../tests/wasm/spec && patch -u -p7 < ../../../etc/wasm/spec-tests.patch)
diff --git a/js/src/jit-test/etc/wasm/README.md b/js/src/jit-test/etc/wasm/README.md
new file mode 100644
index 0000000000..75e4798a88
--- /dev/null
+++ b/js/src/jit-test/etc/wasm/README.md
@@ -0,0 +1,83 @@
+# Wasm Spec Tests
+
+This directory contains scripts and configs to manage the in-tree import of the
+wasm spec testsuite.
+
+## Format of tests
+
+Spec tests are given in `test/core` of the `spec` repository as `.wast` files.
+A `.wast` file is a superset of the `.wat` format with commands for running
+tests.
+
+The spec interpreter can natively consume `.wast` files to run the tests, but
+we cannot run them directly ourselves. To workaround this, we have a tool which
+can convert `.wast` files to `.js` that can be run efficiently in our jit-test
+harness.
+
+## Running tests
+
+Tests are imported to `jit-test` to be run in the JS shell.
+
+To run under `jit-test`:
+```bash
+cd js/src
+./jit-test.py path_to_build/dist/bin/js wasm/spec/
+```
+
+## Test importing
+
+There are many proposals in addition to the canonical spec. Each proposal is a
+fork of the canonical spec and may modify any amount of files.
+
+This causes a challenge for any engine implementing multiple proposals, as any
+proposal may conflict (and often will) with each other. This makes it
+infeasible to merge all spec and proposal repos together.
+
+Testing each proposal separately in full isn't an attractive option either, as
+most tests are unchanged and that would cause a significant amount of wasted
+computation time.
+
+For this reason, we generate a set of separate test-suites that are 'pruned' to
+obtain a minimal set of tests. The tool works by merging each proposal with the
+proposal it is based off of and removing tests that have not changed.
+
+### Configuration
+
+The import tool relies on `config.toml` for the list of proposals to import,
+and `config-lock.toml` for a list of commits to use for each proposal.
+
+The lock file makes test importing deterministic and controllable. This is
+useful as proposals often make inconvenient and breaking changes.
+
+### Operation
+
+```bash
+# Add, remove, or modify proposals
+vim generate-spectests/config.toml
+# Remove locks for any proposals you wish to pull the latest changes on
+vim generate-spectests/config-lock.toml
+# Import the tests
+make update
+# View the tests that were imported
+hg stat
+# Run the imported tests and note failures
+./jit-test.py dist/bin/js wasm/spec/
+# Exclude test failures
+vim generate-spectests/config.toml
+# Re-import the tests to exclude failing tests
+make update
+# Commit the changes
+hg commit
+```
+
+### Debugging import failures
+
+Proposals can often have conflicts with their upstream proposals. This is okay,
+and the test importer will fallback to building tests on an unmerged tree.
+
+This will likely result in extra tests being imported due to spurious
+differences between the proposal and upstream, but generally is okay.
+
+The import tool uses `RUST_LOG` to output debug information. `Makefile`
+automatically uses `RUST_LOG=info`. Change that to `RUST_LOG=debug` to get
+verbose output of all the commands run.
diff --git a/js/src/jit-test/etc/wasm/generate-spectests/Cargo.lock b/js/src/jit-test/etc/wasm/generate-spectests/Cargo.lock
new file mode 100644
index 0000000000..fc48ba7a55
--- /dev/null
+++ b/js/src/jit-test/etc/wasm/generate-spectests/Cargo.lock
@@ -0,0 +1,266 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "aho-corasick"
+version = "0.7.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e37cfd5e7657ada45f742d6e99ca5788580b5c529dc78faf11ece6dc702656f"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "anyhow"
+version = "1.0.40"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "28b2cd92db5cbd74e8e5028f7e27dd7aa3090e89e4f2a197cc7c8dfb69c7063b"
+
+[[package]]
+name = "atty"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
+dependencies = [
+ "hermit-abi",
+ "libc",
+ "winapi",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "env_logger"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "44533bbbb3bb3c1fa17d9f2e4e38bbbaf8396ba82193c4cb1b6445d711445d36"
+dependencies = [
+ "atty",
+ "humantime",
+ "log",
+ "regex",
+ "termcolor",
+]
+
+[[package]]
+name = "hermit-abi"
+version = "0.1.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "322f4de77956e22ed0e5032c359a0f1273f1f7f0d79bfa3b8ffbc730d7fbcc5c"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "humantime"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df004cfca50ef23c36850aaaa59ad52cc70d0e90243c3c7737a4dd32dc7a3c4f"
+dependencies = [
+ "quick-error",
+]
+
+[[package]]
+name = "leb128"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3576a87f2ba00f6f106fdfcd16db1d698d648a26ad8e0573cad8537c3c362d2a"
+
+[[package]]
+name = "libc"
+version = "0.2.96"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5600b4e6efc5421841a2138a6b082e07fe12f9aaa12783d50e5d13325b26b4fc"
+
+[[package]]
+name = "log"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "51b9bbe6c47d51fc3e1a9b945965946b4c44142ab8792c50835a980d362c2710"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "memchr"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0d8caf72986c1a598726adc988bb5984792ef84f5ee5aa50209145ee8077038"
+dependencies = [
+ "unicode-xid",
+]
+
+[[package]]
+name = "quick-error"
+version = "1.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1d01941d82fa2ab50be1e79e6714289dd7cde78eba4c074bc5a4374f650dfe0"
+
+[[package]]
+name = "quote"
+version = "1.0.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c3d0b9745dc2debf507c8422de05d7226cc1f0644216dfdfead988f9b1ab32a7"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "regex"
+version = "1.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e076559ef8e241f2ae3479e36f97bd5741c0330689e217ad51ce2c76808b868a"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.6.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "456c603be3e8d448b072f410900c09faf164fbce2d480456f50eea6e25f9c848"
+
+[[package]]
+name = "serde"
+version = "1.0.126"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec7505abeacaec74ae4778d9d9328fe5a5d04253220a85c4ee022239fc996d03"
+
+[[package]]
+name = "serde_derive"
+version = "1.0.126"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "963a7dbc9895aeac7ac90e74f34a5d5261828f79df35cbed41e10189d3804d43"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "syn"
+version = "1.0.65"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f3a1d708c221c5a612956ef9f75b37e454e88d1f7b899fbd3a18d4252012d663"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-xid",
+]
+
+[[package]]
+name = "termcolor"
+version = "1.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2dfed899f0eb03f32ee8c6a0aabdb8a7949659e3466561fc0adf54e26d88c5f4"
+dependencies = [
+ "winapi-util",
+]
+
+[[package]]
+name = "toml"
+version = "0.5.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a31142970826733df8241ef35dc040ef98c679ab14d7c3e54d827099b3acecaa"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "unicode-width"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3ed742d4ea2bd1176e236172c8429aaf54486e7ac098db29ffe6529e0ce50973"
+
+[[package]]
+name = "unicode-xid"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3"
+
+[[package]]
+name = "wasm-encoder"
+version = "0.25.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4eff853c4f09eec94d76af527eddad4e9de13b11d6286a1ef7134bc30135a2b7"
+dependencies = [
+ "leb128",
+]
+
+[[package]]
+name = "wasm-generate-spectests"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "env_logger",
+ "log",
+ "regex",
+ "serde",
+ "serde_derive",
+ "toml",
+ "wast2js",
+]
+
+[[package]]
+name = "wast"
+version = "55.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4984d3e1406571f4930ba5cf79bd70f75f41d0e87e17506e0bd19b0e5d085f05"
+dependencies = [
+ "leb128",
+ "memchr",
+ "unicode-width",
+ "wasm-encoder",
+]
+
+[[package]]
+name = "wast2js"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "wast",
+]
+
+[[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"
diff --git a/js/src/jit-test/etc/wasm/generate-spectests/Cargo.toml b/js/src/jit-test/etc/wasm/generate-spectests/Cargo.toml
new file mode 100644
index 0000000000..eb28a53537
--- /dev/null
+++ b/js/src/jit-test/etc/wasm/generate-spectests/Cargo.toml
@@ -0,0 +1,19 @@
+[package]
+name = "wasm-generate-spectests"
+version = "0.1.0"
+authors = ["Ryan Hunt <rhunt@eqrion.net>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+regex = "1"
+serde = "1"
+serde_derive = "1"
+toml = "0.5.6"
+log = "0.4"
+env_logger = "0.7"
+anyhow = "1.0.19"
+wast2js = { path = "./wast2js" }
+
+[workspace]
diff --git a/js/src/jit-test/etc/wasm/generate-spectests/README.md b/js/src/jit-test/etc/wasm/generate-spectests/README.md
new file mode 100644
index 0000000000..4423a31077
--- /dev/null
+++ b/js/src/jit-test/etc/wasm/generate-spectests/README.md
@@ -0,0 +1,62 @@
+# generate-spectests
+
+A tool to generate a combined testsuite for the wasm spec and all proposals.
+
+This tool tries to be as robust as possible to deal with upstream breakage, while still generating a minimal testsuite for proposals that don't change many tests.
+
+## Usage
+
+```bash
+# Configure the tests you want
+vim config.toml
+
+# Generate the tests
+# This will create a `repos/` and `tests/` in your working directory
+cargo run
+```
+
+## config.toml
+
+```toml
+# (optional) Text to add to a 'directives.txt' file put in 'js/${repo}/harness'
+harness_directive = ""
+
+# (optional) Text to add to a 'directives.txt' file put in 'js/${repo}'
+directive = ""
+
+# (optional) Tests to include even if they haven't changed with respect to their parent repository
+included_tests = ["test.wast"]
+
+# (optional) Tests to exclude
+excluded_tests = ["test.wast"]
+
+[[repos]]
+# Name of the repository
+name = "sign-extension-ops"
+
+# Url of the repository
+url = "https://github.com/WebAssembly/sign-extension-ops"
+
+# (optional) Name of the repository that is the upstream for this repository.
+# This repository will attempt to merge with this upstream when generating
+# tests. The parent repository must be specified before this repository in the
+# 'config.toml'. If you change this, you must delete the 'repos' directory
+# before generating tests again.
+parent = "spec"
+
+# (optional) Whether to skip merging with upstream, if it exists.
+skip_merge = "false"
+
+# (optional) The commit to checkout when generating tests. If not specified,
+# defaults to the latest 'origin/master'.
+commit = "df34ea92"
+
+# (optional) Text to add to a 'directives.txt' file put in 'js/{$repo}'
+directive = ""
+
+# (optional) Tests to include even if they haven't changed with respect to their parent repository
+included_tests = ["test.wast"]
+
+# (optional) Tests to exclude
+excluded_tests = ["test.wast"]
+```
diff --git a/js/src/jit-test/etc/wasm/generate-spectests/config-lock.toml b/js/src/jit-test/etc/wasm/generate-spectests/config-lock.toml
new file mode 100644
index 0000000000..7db5f73e43
--- /dev/null
+++ b/js/src/jit-test/etc/wasm/generate-spectests/config-lock.toml
@@ -0,0 +1,31 @@
+[[repos]]
+name = 'spec'
+commit = 'b1fbe1a8'
+
+[[repos]]
+name = 'threads'
+commit = '85b562cd'
+
+[[repos]]
+name = 'simd'
+commit = 'a78b98a6'
+
+[[repos]]
+name = 'exception-handling'
+commit = '76419ef8'
+
+[[repos]]
+name = 'memory64'
+commit = '8d8f532d'
+
+[[repos]]
+name = 'function-references'
+commit = 'c4eef9a8'
+
+[[repos]]
+name = 'relaxed-simd'
+commit = 'c4c9ddaf'
+
+[[repos]]
+name = 'extended-const'
+commit = 'dd72ab96'
diff --git a/js/src/jit-test/etc/wasm/generate-spectests/config.toml b/js/src/jit-test/etc/wasm/generate-spectests/config.toml
new file mode 100644
index 0000000000..9341a70ab7
--- /dev/null
+++ b/js/src/jit-test/etc/wasm/generate-spectests/config.toml
@@ -0,0 +1,114 @@
+# Standard 'directives.txt' prologues for jit-tests
+harness_directive = "|jit-test| skip-if: true"
+directive = "|jit-test| test-also=--wasm-compiler=optimizing; test-also=--wasm-compiler=baseline; test-also=--wasm-test-serialization; test-also=--test-wasm-await-tier2; test-also=--disable-wasm-huge-memory; skip-variant-if: --disable-wasm-huge-memory, !wasmHugeMemorySupported(); local-include:harness/harness.js"
+
+# Failing tests across all testsuites
+excluded_tests = [
+  # false-positive windows-specific failures
+  "align.wast",
+  # bulk-memory-operations/issues/133 (data.wast:161)
+  "data.wast",
+  # memory limits can be encoded with more bytes now
+  "binary.wast",
+  "binary-leb128.wast",
+  # testing that multiple tables fail (imports.wast:309)
+  "imports.wast",
+  # bulk-memory-operations/issues/133 (linking.wast:206)
+  "linking.wast",
+  # bulk-memory-operations/issues/133 (elem.wast:142)
+  "elem.wast",
+  # test harness doesn't acquire global values correctly
+  "exports.wast",
+  # false-positive windows-specific failure
+  "memory_trap.wast",
+  # false-positive error on invalid UTF-8 custom section name (utf8-custom-section-id.wast:6)
+  "utf8-custom-section-id.wast",
+  # invalid table maximum length for web embeddings
+  "table.wast",
+  # fails after a bottom-type has been added to validation
+  "unreached-invalid.wast",
+  # argument is not wasm value
+  "^select.wast",
+]
+
+[[repos]]
+name = "spec"
+url = "https://github.com/WebAssembly/spec"
+excluded_tests = []
+directive = "; test-also=--no-avx; skip-variant-if: --no-avx, !getBuildConfiguration().x86 && !getBuildConfiguration().x64 || getBuildConfiguration().simulator"
+
+[[repos]]
+name = "threads"
+url = "https://github.com/WebAssembly/threads"
+branch = "main"
+parent = "spec"
+excluded_tests = [
+  "atomic.wast",
+  # testing that multi-value isn't implemented (func.wast:492)
+  "func.wast",
+  # testing that multi-value isn't implemented (type.wast:52)
+  "type.wast"
+]
+# Skip in WPT where we can't guard on features being enabled
+skip_wpt = true
+# Skip in jit-test when it's not enabled
+directive = "; skip-if: !wasmThreadsEnabled()"
+
+[[repos]]
+name = "exception-handling"
+url = "https://github.com/WebAssembly/exception-handling"
+branch = "main"
+parent = "spec"
+# Skip in jit-test when it's not enabled
+directive = "; --wasm-exceptions; skip-if: !wasmExceptionsEnabled()"
+excluded_tests = [
+  # This gets included due to divergence between the proposal repo and the
+  # upstream spec, it can be removed when the repo is rebased.
+  "global.wast"
+]
+
+[[repos]]
+name = "memory64"
+url = "https://github.com/mozilla-spidermonkey/memory64"
+branch = "test-cases"
+directive = "; skip-if: !wasmMemory64Enabled()"
+excluded_tests = []
+
+[[repos]]
+name = "function-references"
+url = "https://github.com/WebAssembly/function-references"
+branch = "main"
+parent = "spec"
+directive = "; --wasm-function-references; skip-if: !wasmFunctionReferencesEnabled()"
+excluded_tests = [
+  # return_call_ref not implemented
+  "return_call_ref.wast",
+  # table function elem subtyping
+  "ref_is_null.wast",
+  # cannot expose indexed reference type
+  "ref_null.wast",
+  # parameter subtyping
+  "type-equivalence.wast",
+  # NYI WasmValType.h:259
+  "table-sub.wast",
+  # unrelated
+  "tokens.wast",
+  # irrelevant
+  "simd_lane.wast",
+]
+
+[[repos]]
+name = "relaxed-simd"
+url = "https://github.com/WebAssembly/relaxed-simd"
+branch = "main"
+parent = "spec"
+directive = "; --wasm-relaxed-simd; skip-if: !wasmRelaxedSimdEnabled()"
+excluded_tests = []
+
+[[repos]]
+name = "extended-const"
+url = "https://github.com/WebAssembly/extended-const"
+branch = "main"
+parent = "spec"
+directive = "; --wasm-extended-const; skip-if: !wasmExtendedConstEnabled()"
+excluded_tests = []
diff --git a/js/src/jit-test/etc/wasm/generate-spectests/src/main.rs b/js/src/jit-test/etc/wasm/generate-spectests/src/main.rs
new file mode 100644
index 0000000000..40f27afcc4
--- /dev/null
+++ b/js/src/jit-test/etc/wasm/generate-spectests/src/main.rs
@@ -0,0 +1,490 @@
+use std::env;
+use std::ffi::OsStr;
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+
+use anyhow::{bail, Result};
+use regex::{RegexSet, RegexSetBuilder};
+use serde_derive::{Deserialize, Serialize};
+use toml;
+use wast2js;
+
+use log::{debug, info, warn};
+
+// Data structures
+
+#[derive(Debug, Default, Serialize, Deserialize)]
+struct Config {
+    #[serde(default)]
+    harness_directive: Option<String>,
+    #[serde(default)]
+    directive: Option<String>,
+    #[serde(default)]
+    included_tests: Vec<String>,
+    #[serde(default)]
+    excluded_tests: Vec<String>,
+    repos: Vec<Repo>,
+}
+
+impl Config {
+    fn find_repo_mut(&mut self, name: &str) -> Option<&mut Repo> {
+        self.repos.iter_mut().find(|x| &x.name == name)
+    }
+}
+
+#[derive(Debug, Default, Serialize, Deserialize)]
+struct Repo {
+    name: String,
+    url: String,
+    #[serde(default)]
+    branch: Option<String>,
+    #[serde(default)]
+    parent: Option<String>,
+    #[serde(default)]
+    directive: Option<String>,
+    #[serde(default)]
+    included_tests: Vec<String>,
+    #[serde(default)]
+    excluded_tests: Vec<String>,
+    #[serde(default)]
+    skip_wast: bool,
+    #[serde(default)]
+    skip_js: bool,
+}
+
+#[derive(Debug, Default, Serialize, Deserialize)]
+struct Lock {
+    repos: Vec<LockRepo>,
+}
+
+impl Lock {
+    fn find_commit(&self, name: &str) -> Option<&str> {
+        self.repos
+            .iter()
+            .find(|x| &x.name == name)
+            .map(|x| x.commit.as_ref())
+    }
+
+    fn set_commit(&mut self, name: &str, commit: &str) {
+        if let Some(lock) = self.repos.iter_mut().find(|x| &x.name == name) {
+            lock.commit = commit.to_owned();
+        } else {
+            self.repos.push(LockRepo {
+                name: name.to_owned(),
+                commit: commit.to_owned(),
+            });
+        }
+    }
+}
+
+#[derive(Debug, Default, Serialize, Deserialize)]
+struct LockRepo {
+    name: String,
+    commit: String,
+}
+
+#[derive(Debug)]
+enum Merge {
+    Standalone,
+    Merged,
+    Conflicted,
+}
+
+#[derive(Debug)]
+struct Status {
+    commit_base_hash: String,
+    commit_final_message: String,
+    merged: Merge,
+    built: bool,
+}
+
+// Roll-your-own CLI utilities
+
+fn run(name: &str, args: &[&str]) -> Result<String> {
+    debug!("{} {:?}", name, args);
+    let output = Command::new(name).args(args).output()?;
+    let stdout = String::from_utf8(output.stdout)?.trim().to_owned();
+    let stderr = String::from_utf8(output.stderr)?.trim().to_owned();
+    if !stdout.is_empty() {
+        debug!("{}", stdout);
+    }
+    if !stderr.is_empty() {
+        debug!("{}", stderr);
+    }
+
+    if output.status.success() {
+        Ok(stdout)
+    } else {
+        bail!("{}: {}\n{}", name.to_owned(), stdout, stderr)
+    }
+}
+
+fn change_dir(dir: &str) -> impl Drop {
+    #[must_use]
+    struct Reset {
+        previous: PathBuf,
+    }
+    impl Drop for Reset {
+        fn drop(&mut self) {
+            debug!("cd {}", self.previous.display());
+            env::set_current_dir(&self.previous).unwrap()
+        }
+    }
+
+    let previous = Reset {
+        previous: env::current_dir().unwrap(),
+    };
+    debug!("cd {}", dir);
+    env::set_current_dir(dir).unwrap();
+    previous
+}
+
+fn find(dir: &str) -> Vec<PathBuf> {
+    let mut paths = Vec::new();
+
+    fn find(dir: &str, paths: &mut Vec<PathBuf>) {
+        for entry in fs::read_dir(dir).unwrap().map(|x| x.unwrap()) {
+            let path = entry.path();
+
+            if entry.file_type().unwrap().is_dir() {
+                find(path.to_str().unwrap(), paths);
+            } else {
+                paths.push(path);
+            }
+        }
+    }
+
+    find(dir, &mut paths);
+    paths
+}
+
+fn write_string<P: AsRef<Path>>(path: P, text: &str) -> Result<()> {
+    let path = path.as_ref();
+    if let Some(dir) = path.parent() {
+        let _ = fs::create_dir_all(dir);
+    }
+    fs::write(path, text.as_bytes())?;
+    Ok(())
+}
+
+// The main script
+
+fn main() {
+    env_logger::init();
+
+    // Load the config
+    let mut config: Config =
+        toml::from_str(&fs::read_to_string("config.toml").expect("failed to read config.toml"))
+            .expect("invalid config.toml");
+
+    // Load the lock file, or default to no pinned commits
+    let mut lock: Lock = if Path::new("config-lock.toml").exists() {
+        toml::from_str(
+            &fs::read_to_string("config-lock.toml").expect("failed to read config-lock.toml"),
+        )
+        .expect("invalid config-lock.toml")
+    } else {
+        Lock::default()
+    };
+
+    // Clean old tests and initialize the repo if it doesn't exist
+    let specs_dir = "specs/";
+    clean_and_init_dirs(specs_dir);
+
+    // Generate the tests
+    let mut successes = Vec::new();
+    let mut failures = Vec::new();
+    {
+        // Change to the `specs/` dir where all the work happens
+        let _cd = change_dir(specs_dir);
+        for repo in &config.repos {
+            info!("Processing {:#?}", repo);
+
+            match build_repo(repo, &config, &lock) {
+                Ok(status) => successes.push((repo.name.clone(), status)),
+                Err(err) => failures.push((repo.name.clone(), err)),
+            };
+        }
+    }
+
+    // Abort if we had a failure
+    if !failures.is_empty() {
+        warn!("Failed.");
+        for (name, err) in &failures {
+            warn!("{}: (failure) {:?}", name, err);
+        }
+        std::process::exit(1);
+    }
+
+    // Display successful results
+    info!("Done.");
+    for (name, status) in &successes {
+        let repo = config.find_repo_mut(&name).unwrap();
+        lock.set_commit(&name, &status.commit_base_hash);
+
+        info!(
+            "{}: ({} {}) {}",
+            repo.name,
+            match status.merged {
+                Merge::Standalone => "standalone",
+                Merge::Merged => "merged",
+                Merge::Conflicted => "conflicted",
+            },
+            if status.built { "building" } else { "broken" },
+            status.commit_final_message.trim_end()
+        );
+    }
+
+    // Commit the new lock file
+    write_string("config-lock.toml", &toml::to_string_pretty(&lock).unwrap()).unwrap();
+}
+
+fn clean_and_init_dirs(specs_dir: &str) {
+    if !Path::new(specs_dir).exists() {
+        fs::create_dir(specs_dir).unwrap();
+        run("git", &["-C", specs_dir, "init"]).unwrap();
+    }
+
+    let _ = fs::remove_dir_all("./tests");
+}
+
+fn build_repo(repo: &Repo, config: &Config, lock: &Lock) -> Result<Status> {
+    let remote_name = &repo.name;
+    let remote_url = &repo.url;
+    let remote_branch = repo.branch.as_ref().map(|x| x.as_str()).unwrap_or("master");
+    let branch_upstream = format!("{}/{}", repo.name, remote_branch);
+    let branch_base = repo.name.clone();
+
+    // Initialize our remote and branches if they don't exist
+    let remotes = run("git", &["remote"])?;
+    if !remotes.lines().any(|x| x == repo.name) {
+        run("git", &["remote", "add", remote_name, &remote_url])?;
+        run("git", &["fetch", remote_name])?;
+        run("git", &["branch", &branch_base, &branch_upstream])?;
+    }
+
+    // Set the upstream to the correct branch
+    run(
+        "git",
+        &[
+            "branch",
+            &branch_base,
+            "--set-upstream-to",
+            &branch_upstream,
+        ],
+    )?;
+
+    // Fetch the latest changes for this repo
+    run("git", &["fetch", remote_name])?;
+
+    // Checkout the pinned commit, if any, and get the absolute commit hash
+    let base_treeish = lock.find_commit(&repo.name).unwrap_or(&branch_upstream);
+    run("git", &["checkout", &branch_base])?;
+    run("git", &["reset", base_treeish, "--hard"])?;
+    let commit_base_hash = run("git", &["log", "--pretty=%h", "-n", "1"])?
+        .trim()
+        .to_owned();
+
+    // Try to merge with parent repo, if specified
+    let merged = try_merge_parent(repo, &commit_base_hash)?;
+
+    // Exclude files specified from the config and repo
+    let mut excluded_files = Vec::new();
+    excluded_files.extend_from_slice(&config.excluded_tests);
+    excluded_files.extend_from_slice(&repo.excluded_tests);
+    let exclude = RegexSetBuilder::new(&excluded_files).build().unwrap();
+
+    // Try to build the test suite on this commit. This may fail due to merging
+    // with a parent repo, in which case we will try again in an unmerged state.
+    let mut built = false;
+    match try_build_tests(&exclude) {
+        Ok(()) => built = true,
+        Err(err) => warn!("Failed to build tests: {:?}", err),
+    };
+    // if try_build_tests(&exclude).is_err() {
+    //     if repo.parent.is_some() {
+    //         warn!(
+    //             "Failed to build interpreter. Retrying on unmerged commit ({})",
+    //             &commit_base_hash
+    //         );
+    //         run("git", &["reset", &commit_base_hash, "--hard"])?;
+    //         built = try_build_tests(&exclude).is_ok();
+    //     } else {
+    //         built = false;
+    //     }
+    // }
+    // if !built {
+    //     warn!("Failed to build interpreter, Won't emit js/html");
+    // }
+
+    // Get the final commit message we ended up on
+    let commit_final_message = run("git", &["log", "--oneline", "-n", "1"])?;
+
+    // Compute the source files that changed, and use that to filter the files
+    // we copy over. We can't compare the generated tests, because for a
+    // generated WPT we need to copy both the .js and .html even if only
+    // one of those is different from the master.
+    let tests_changed = find_tests_changed(repo)?;
+    info!("Changed tests: {:#?}", tests_changed);
+
+    // Include the changed tests, specified files, and `harness/` directory
+    let mut included_files = Vec::new();
+    included_files.extend_from_slice(&tests_changed);
+    included_files.extend_from_slice(&config.included_tests);
+    included_files.extend_from_slice(&repo.included_tests);
+    included_files.push("harness/".to_owned());
+    let include = RegexSetBuilder::new(&included_files).build().unwrap();
+
+    // Copy over all the desired test-suites
+    if !repo.skip_wast {
+        copy_tests(repo, "test/core", "../tests", "wast", &include, &exclude);
+    }
+    if built && !repo.skip_js {
+        copy_tests(repo, "js", "../tests", "js", &include, &exclude);
+        copy_directives(repo, config)?;
+    }
+
+    Ok(Status {
+        commit_final_message,
+        commit_base_hash,
+        merged,
+        built,
+    })
+}
+
+fn try_merge_parent(repo: &Repo, commit_base_hash: &str) -> Result<Merge> {
+    if !repo.parent.is_some() {
+        return Ok(Merge::Standalone);
+    }
+    let parent = repo.parent.as_ref().unwrap();
+
+    // Try to merge with the parent branch.
+    let message = format!("Merging {}:{}with {}", repo.name, commit_base_hash, parent);
+    Ok(
+        if !run("git", &["merge", "-q", parent, "-m", &message]).is_ok() {
+            // Ignore merge conflicts in the document directory.
+            if !run("git", &["checkout", "--ours", "document"]).is_ok()
+                || !run("git", &["add", "document"]).is_ok()
+                || !run("git", &["-c", "core.editor=true", "merge", "--continue"]).is_ok()
+            {
+                // Reset to master if we failed
+                warn!(
+                    "Failed to merge {}, falling back to {}.",
+                    repo.name, &commit_base_hash
+                );
+                run("git", &["merge", "--abort"])?;
+                run("git", &["reset", &commit_base_hash, "--hard"])?;
+                Merge::Conflicted
+            } else {
+                Merge::Merged
+            }
+        } else {
+            Merge::Merged
+        },
+    )
+}
+
+fn try_build_tests(exclude: &RegexSet) -> Result<()> {
+    let _ = fs::remove_dir_all("./js");
+    fs::create_dir("./js")?;
+
+    let paths = find("./test/core/");
+    for path in paths {
+        if path.extension() != Some(OsStr::new("wast")) {
+            continue;
+        }
+
+        let stripped_path = path.strip_prefix("./test/core/").unwrap();
+        let stripped_path_str = stripped_path.to_str().unwrap();
+        if exclude.is_match(stripped_path_str) {
+            continue;
+        }
+
+        let source = std::fs::read_to_string(&path)?;
+        let script = wast2js::convert(&path, &source)?;
+
+        std::fs::write(
+            Path::new("./js").join(&path.with_extension("wast.js").file_name().unwrap()),
+            &script,
+        )?;
+    }
+
+    fs::create_dir("./js/harness")?;
+    write_string("./js/harness/harness.js", &wast2js::harness())?;
+
+    Ok(())
+}
+
+fn copy_tests(
+    repo: &Repo,
+    src_dir: &str,
+    dst_dir: &str,
+    test_name: &str,
+    include: &RegexSet,
+    exclude: &RegexSet,
+) {
+    for path in find(src_dir) {
+        let stripped_path = path.strip_prefix(src_dir).unwrap();
+        let stripped_path_str = stripped_path.to_str().unwrap();
+
+        if !include.is_match(stripped_path_str) || exclude.is_match(stripped_path_str) {
+            continue;
+        }
+
+        let out_path = Path::new(dst_dir)
+            .join(test_name)
+            .join(&repo.name)
+            .join(&stripped_path);
+        let out_dir = out_path.parent().unwrap();
+        let _ = fs::create_dir_all(out_dir);
+        fs::copy(path, out_path).unwrap();
+    }
+}
+
+fn copy_directives(repo: &Repo, config: &Config) -> Result<()> {
+    // Write directives files
+    if let Some(harness_directive) = &config.harness_directive {
+        let directives_path = Path::new("../tests/js")
+            .join(&repo.name)
+            .join("harness/directives.txt");
+        write_string(&directives_path, harness_directive)?;
+    }
+    let directives = format!(
+        "{}{}",
+        config.directive.as_ref().map(|x| x.as_str()).unwrap_or(""),
+        repo.directive.as_ref().map(|x| x.as_str()).unwrap_or("")
+    );
+    if !directives.is_empty() {
+        let directives_path = Path::new("../tests/js")
+            .join(&repo.name)
+            .join("directives.txt");
+        write_string(&directives_path, &directives)?;
+    }
+    Ok(())
+}
+
+fn find_tests_changed(repo: &Repo) -> Result<Vec<String>> {
+    let files_changed = if let Some(parent) = repo.parent.as_ref() {
+        run(
+            "git",
+            &["diff", "--name-only", &repo.name, &parent, "test/core"],
+        )?
+        .lines()
+        .map(|x| PathBuf::from(x))
+        .collect()
+    } else {
+        find("test/core")
+    };
+
+    let mut tests_changed = Vec::new();
+    for path in files_changed {
+        if path.extension().map(|x| x.to_str().unwrap()) != Some("wast") {
+            continue;
+        }
+
+        let name = path.file_name().unwrap().to_str().unwrap().to_owned();
+        tests_changed.push(name);
+    }
+    Ok(tests_changed)
+}
diff --git a/js/src/jit-test/etc/wasm/generate-spectests/wast2js/Cargo.toml b/js/src/jit-test/etc/wasm/generate-spectests/wast2js/Cargo.toml
new file mode 100644
index 0000000000..4329cc10fb
--- /dev/null
+++ b/js/src/jit-test/etc/wasm/generate-spectests/wast2js/Cargo.toml
@@ -0,0 +1,11 @@
+[package]
+name = "wast2js"
+version = "0.1.0"
+authors = ["Ryan Hunt <rhunt@eqrion.net>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+anyhow = "1.0.19"
+wast = "55.0.0"
diff --git a/js/src/jit-test/etc/wasm/generate-spectests/wast2js/README.md b/js/src/jit-test/etc/wasm/generate-spectests/wast2js/README.md
new file mode 100644
index 0000000000..c06210bb04
--- /dev/null
+++ b/js/src/jit-test/etc/wasm/generate-spectests/wast2js/README.md
@@ -0,0 +1,3 @@
+# wast2js
+
+Mozilla specific converter from `.wast` to `.js` for SpiderMonkey jit-tests.
diff --git a/js/src/jit-test/etc/wasm/generate-spectests/wast2js/src/convert.rs b/js/src/jit-test/etc/wasm/generate-spectests/wast2js/src/convert.rs
new file mode 100644
index 0000000000..c6516cb0d0
--- /dev/null
+++ b/js/src/jit-test/etc/wasm/generate-spectests/wast2js/src/convert.rs
@@ -0,0 +1,672 @@
+/* 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.
+ */
+
+use anyhow::{bail, Context as _, Result};
+use std::fmt::Write;
+use std::path::Path;
+use std::str;
+
+use super::out::*;
+
+const HARNESS: &'static str = include_str!("./harness.js");
+const LICENSE: &'static str = include_str!("./license.js");
+
+pub fn harness() -> String {
+    HARNESS.to_string()
+}
+
+pub fn convert<P: AsRef<Path>>(path: P, wast: &str) -> Result<String> {
+    let filename = path.as_ref();
+    let adjust_wast = |mut err: wast::Error| {
+        err.set_path(filename);
+        err.set_text(wast);
+        err
+    };
+
+    let mut lexer = wast::lexer::Lexer::new(wast);
+    // The 'names.wast' spec test has confusable unicode -- disable detection.
+    lexer.allow_confusing_unicode(filename.ends_with("names.wast"));
+    let buf = wast::parser::ParseBuffer::new_with_lexer(lexer).map_err(adjust_wast)?;
+    let ast = wast::parser::parse::<wast::Wast>(&buf).map_err(adjust_wast)?;
+
+    let mut out = String::new();
+
+    writeln!(&mut out, "{}", LICENSE)?;
+    writeln!(&mut out, "// {}", filename.display())?;
+
+    let mut current_instance: Option<usize> = None;
+
+    for directive in ast.directives {
+        let sp = directive.span();
+        let (line, col) = sp.linecol_in(wast);
+        writeln!(&mut out, "")?;
+        convert_directive(
+            directive,
+            &mut current_instance,
+            filename,
+            line,
+            col,
+            wast,
+            &mut out,
+        )
+        .with_context(|| {
+            format!(
+                "failed to convert directive on {}:{}:{}",
+                filename.display(),
+                line + 1,
+                col
+            )
+        })?;
+    }
+
+    Ok(out)
+}
+
+fn convert_directive(
+    directive: wast::WastDirective,
+    current_instance: &mut Option<usize>,
+    filename: &Path,
+    line: usize,
+    col: usize,
+    wast: &str,
+    out: &mut String,
+) -> Result<()> {
+    use wast::WastDirective::*;
+
+    if col == 1 {
+        writeln!(out, "// {}:{}", filename.display(), line + 1)?;
+    } else {
+        writeln!(out, "// {}:{}:{}", filename.display(), line + 1, col)?;
+    }
+    match directive {
+        Wat(wast::QuoteWat::Wat(wast::Wat::Module(module))) => {
+            let next_instance = current_instance.map(|x| x + 1).unwrap_or(0);
+            let module_text = module_to_js_string(&module, wast)?;
+
+            writeln!(
+                out,
+                "let ${} = instantiate(`{}`);",
+                next_instance, module_text
+            )?;
+            if let Some(id) = module.id {
+                writeln!(
+                    out,
+                    "register(${}, {});",
+                    next_instance,
+                    format!("`{}`", escape_template_string(id.name()))
+                )?;
+            }
+
+            *current_instance = Some(next_instance);
+        }
+        Wat(_) => {
+            write!(out, "// unsupported quote wat")?;
+        }
+        Register {
+            span: _,
+            name,
+            module,
+        } => {
+            let instanceish = module
+                .map(|x| format!("`{}`", escape_template_string(x.name())))
+                .unwrap_or_else(|| format!("${}", current_instance.unwrap()));
+
+            writeln!(
+                out,
+                "register({}, `{}`);",
+                instanceish,
+                escape_template_string(name)
+            )?;
+        }
+        Invoke(i) => {
+            let invoke_node = invoke_to_js(current_instance, i)?;
+            writeln!(out, "{};", invoke_node.output(0))?;
+        }
+        AssertReturn {
+            span: _,
+            exec,
+            results,
+        } => {
+            let exec_node = execute_to_js(current_instance, exec, wast)?;
+            let expected_node = to_js_value_array(&results, assert_expression_to_js_value)?;
+            writeln!(
+                out,
+                "{};",
+                JSNode::Assert {
+                    name: "assert_return".to_string(),
+                    exec: exec_node,
+                    expected: expected_node,
+                }
+                .output(0),
+            )?;
+        }
+        AssertTrap {
+            span: _,
+            exec,
+            message,
+        } => {
+            let exec_node = execute_to_js(current_instance, exec, wast)?;
+            let expected_node = Box::new(JSNode::Raw(format!(
+                "`{}`",
+                escape_template_string(message)
+            )));
+            writeln!(
+                out,
+                "{};",
+                JSNode::Assert {
+                    name: "assert_trap".to_string(),
+                    exec: exec_node,
+                    expected: expected_node,
+                }
+                .output(0),
+            )?;
+        }
+        AssertExhaustion {
+            span: _,
+            call,
+            message,
+        } => {
+            let exec_node = invoke_to_js(current_instance, call)?;
+            let expected_node = Box::new(JSNode::Raw(format!(
+                "`{}`",
+                escape_template_string(message)
+            )));
+            writeln!(
+                out,
+                "{};",
+                JSNode::Assert {
+                    name: "assert_exhaustion".to_string(),
+                    exec: exec_node,
+                    expected: expected_node,
+                }
+                .output(0),
+            )?;
+        }
+        AssertInvalid {
+            span: _,
+            module,
+            message,
+        } => {
+            let text = match module {
+                wast::QuoteWat::Wat(wast::Wat::Module(m)) => module_to_js_string(&m, wast)?,
+                wast::QuoteWat::QuoteModule(_, source) => quote_module_to_js_string(source)?,
+                other => bail!("unsupported {:?} in assert_invalid", other),
+            };
+            let exec = Box::new(JSNode::Raw(format!("instantiate(`{}`)", text)));
+            let expected_node = Box::new(JSNode::Raw(format!(
+                "`{}`",
+                escape_template_string(message)
+            )));
+            writeln!(
+                out,
+                "{};",
+                JSNode::Assert {
+                    name: "assert_invalid".to_string(),
+                    exec: exec,
+                    expected: expected_node,
+                }
+                .output(0),
+            )?;
+        }
+        AssertMalformed {
+            module,
+            span: _,
+            message,
+        } => {
+            let text = match module {
+                wast::QuoteWat::Wat(wast::Wat::Module(m)) => module_to_js_string(&m, wast)?,
+                wast::QuoteWat::QuoteModule(_, source) => quote_module_to_js_string(source)?,
+                other => bail!("unsupported {:?} in assert_malformed", other),
+            };
+            let exec = Box::new(JSNode::Raw(format!("instantiate(`{}`)", text)));
+            let expected_node = Box::new(JSNode::Raw(format!(
+                "`{}`",
+                escape_template_string(message)
+            )));
+            writeln!(
+                out,
+                "{};",
+                JSNode::Assert {
+                    name: "assert_malformed".to_string(),
+                    exec: exec,
+                    expected: expected_node,
+                }
+                .output(0),
+            )?;
+        }
+        AssertUnlinkable {
+            span: _,
+            module,
+            message,
+        } => {
+            let text = match module {
+                wast::Wat::Module(module) => module_to_js_string(&module, wast)?,
+                other => bail!("unsupported {:?} in assert_unlinkable", other),
+            };
+            let exec = Box::new(JSNode::Raw(format!("instantiate(`{}`)", text)));
+            let expected_node = Box::new(JSNode::Raw(format!(
+                "`{}`",
+                escape_template_string(message)
+            )));
+            writeln!(
+                out,
+                "{};",
+                JSNode::Assert {
+                    name: "assert_unlinkable".to_string(),
+                    exec: exec,
+                    expected: expected_node,
+                }
+                .output(0),
+            )?;
+        }
+        AssertException { span: _, exec } => {
+            // This assert doesn't have a second parameter, so we don't bother
+            // formatting it using an Assert node.
+            let exec_node = execute_to_js(current_instance, exec, wast)?;
+            writeln!(out, "assert_exception(() => {});", exec_node.output(0))?;
+        }
+    }
+
+    Ok(())
+}
+
+fn escape_template_string(text: &str) -> String {
+    let mut escaped = String::new();
+    for c in text.chars() {
+        match c {
+            '$' => escaped.push_str("$$"),
+            '\\' => escaped.push_str("\\\\"),
+            '`' => escaped.push_str("\\`"),
+            c if c.is_ascii_control() && c != '\n' && c != '\t' => {
+                escaped.push_str(&format!("\\x{:02x}", c as u32))
+            }
+            c if !c.is_ascii() => escaped.push_str(&c.escape_unicode().to_string()),
+            c => escaped.push(c),
+        }
+    }
+    escaped
+}
+
+fn span_to_offset(span: wast::token::Span, text: &str) -> Result<usize> {
+    let (span_line, span_col) = span.linecol_in(text);
+    let mut cur = 0;
+    // Use split_terminator instead of lines so that if there is a `\r`,
+    // it is included in the offset calculation. The `+1` values below
+    // account for the `\n`.
+    for (i, line) in text.split_terminator('\n').enumerate() {
+        if span_line == i {
+            assert!(span_col < line.len());
+            return Ok(cur + span_col);
+        }
+        cur += line.len() + 1;
+    }
+    bail!("invalid line/col");
+}
+
+fn closed_module(module: &str) -> Result<&str> {
+    enum State {
+        Module,
+        QStr,
+        EscapeQStr,
+    }
+
+    let mut i = 0;
+    let mut level = 1;
+    let mut state = State::Module;
+
+    let mut chars = module.chars();
+    while level != 0 {
+        let next = match chars.next() {
+            Some(next) => next,
+            None => bail!("was unable to close module"),
+        };
+        match state {
+            State::Module => match next {
+                '(' => level += 1,
+                ')' => level -= 1,
+                '"' => state = State::QStr,
+                _ => {}
+            },
+            State::QStr => match next {
+                '"' => state = State::Module,
+                '\\' => state = State::EscapeQStr,
+                _ => {}
+            },
+            State::EscapeQStr => match next {
+                _ => state = State::QStr,
+            },
+        }
+        i += next.len_utf8();
+    }
+    return Ok(&module[0..i]);
+}
+
+fn module_to_js_string(module: &wast::core::Module, wast: &str) -> Result<String> {
+    let offset = span_to_offset(module.span, wast)?;
+    let opened_module = &wast[offset..];
+    if !opened_module.starts_with("module") {
+        return Ok(escape_template_string(opened_module));
+    }
+    Ok(escape_template_string(&format!(
+        "({}",
+        closed_module(opened_module)?
+    )))
+}
+
+fn quote_module_to_js_string(quotes: Vec<(wast::token::Span, &[u8])>) -> Result<String> {
+    let mut text = String::new();
+    for (_, src) in quotes {
+        text.push_str(str::from_utf8(src)?);
+        text.push_str(" ");
+    }
+    let escaped = escape_template_string(&text);
+    Ok(escaped)
+}
+
+fn invoke_to_js(current_instance: &Option<usize>, i: wast::WastInvoke) -> Result<Box<JSNode>> {
+    let instanceish = i
+        .module
+        .map(|x| format!("`{}`", escape_template_string(x.name())))
+        .unwrap_or_else(|| format!("${}", current_instance.unwrap()));
+    let body = to_js_value_array(&i.args, arg_to_js_value)?;
+
+    Ok(Box::new(JSNode::Invoke {
+        instance: instanceish,
+        name: escape_template_string(i.name),
+        body: body,
+    }))
+}
+
+fn execute_to_js(
+    current_instance: &Option<usize>,
+    exec: wast::WastExecute,
+    wast: &str,
+) -> Result<Box<JSNode>> {
+    match exec {
+        wast::WastExecute::Invoke(invoke) => invoke_to_js(current_instance, invoke),
+        wast::WastExecute::Wat(module) => {
+            let text = match module {
+                wast::Wat::Module(module) => module_to_js_string(&module, wast)?,
+                other => bail!("unsupported {:?} at execute_to_js", other),
+            };
+            Ok(Box::new(JSNode::Raw(format!("instantiate(`{}`)", text))))
+        }
+        wast::WastExecute::Get { module, global } => {
+            let instanceish = module
+                .map(|x| format!("`{}`", escape_template_string(x.name())))
+                .unwrap_or_else(|| format!("${}", current_instance.unwrap()));
+            Ok(Box::new(JSNode::Raw(format!(
+                "get({}, `{}`)",
+                instanceish, global
+            ))))
+        }
+    }
+}
+
+fn to_js_value_array<T, F: Fn(&T) -> Result<String>>(vals: &[T], func: F) -> Result<Box<JSNode>> {
+    let mut value_nodes: Vec<Box<JSNode>> = vec![];
+    for val in vals {
+        let converted_value = (func)(val)?;
+        value_nodes.push(Box::new(JSNode::Raw(converted_value)));
+    }
+
+    Ok(Box::new(JSNode::Array(value_nodes)))
+}
+
+fn to_js_value_array_string<T, F: Fn(&T) -> Result<String>>(vals: &[T], func: F) -> Result<String> {
+    let array = to_js_value_array(vals, func)?;
+    Ok(array.output(NOWRAP))
+}
+
+fn f32_needs_bits(a: f32) -> bool {
+    if a.is_infinite() {
+        return false;
+    }
+    return a.is_nan()
+        || ((a as f64) as f32).to_bits() != a.to_bits()
+        || (format!("{:.}", a).parse::<f64>().unwrap() as f32).to_bits() != a.to_bits();
+}
+
+fn f64_needs_bits(a: f64) -> bool {
+    return a.is_nan();
+}
+
+fn f32x4_needs_bits(a: &[wast::token::Float32; 4]) -> bool {
+    a.iter().any(|x| {
+        let as_f32 = f32::from_bits(x.bits);
+        f32_needs_bits(as_f32)
+    })
+}
+
+fn f64x2_needs_bits(a: &[wast::token::Float64; 2]) -> bool {
+    a.iter().any(|x| {
+        let as_f64 = f64::from_bits(x.bits);
+        f64_needs_bits(as_f64)
+    })
+}
+
+fn f32_to_js_value(val: f32) -> String {
+    if val == f32::INFINITY {
+        format!("Infinity")
+    } else if val == f32::NEG_INFINITY {
+        format!("-Infinity")
+    } else if val.is_sign_negative() && val == 0f32 {
+        format!("-0")
+    } else {
+        format!("{:.}", val)
+    }
+}
+
+fn f64_to_js_value(val: f64) -> String {
+    if val == f64::INFINITY {
+        format!("Infinity")
+    } else if val == f64::NEG_INFINITY {
+        format!("-Infinity")
+    } else if val.is_sign_negative() && val == 0f64 {
+        format!("-0")
+    } else {
+        format!("{:.}", val)
+    }
+}
+
+fn float32_to_js_value(val: &wast::token::Float32) -> String {
+    let as_f32 = f32::from_bits(val.bits);
+    if f32_needs_bits(as_f32) {
+        format!(
+            "bytes(\"f32\", {})",
+            to_js_value_array_string(&val.bits.to_le_bytes(), |x| Ok(format!("0x{:x}", x)))
+                .unwrap(),
+        )
+    } else {
+        format!("value(\"f32\", {})", f32_to_js_value(as_f32))
+    }
+}
+
+fn float64_to_js_value(val: &wast::token::Float64) -> String {
+    let as_f64 = f64::from_bits(val.bits);
+    if f64_needs_bits(as_f64) {
+        format!(
+            "bytes(\"f64\", {})",
+            to_js_value_array_string(&val.bits.to_le_bytes(), |x| Ok(format!("0x{:x}", x)))
+                .unwrap(),
+        )
+    } else {
+        format!("value(\"f64\", {})", f64_to_js_value(as_f64))
+    }
+}
+
+fn f32_pattern_to_js_value(pattern: &wast::core::NanPattern<wast::token::Float32>) -> String {
+    use wast::core::NanPattern::*;
+    match pattern {
+        CanonicalNan => format!("`canonical_nan`"),
+        ArithmeticNan => format!("`arithmetic_nan`"),
+        Value(x) => float32_to_js_value(x),
+    }
+}
+
+fn f64_pattern_to_js_value(pattern: &wast::core::NanPattern<wast::token::Float64>) -> String {
+    use wast::core::NanPattern::*;
+    match pattern {
+        CanonicalNan => format!("`canonical_nan`"),
+        ArithmeticNan => format!("`arithmetic_nan`"),
+        Value(x) => float64_to_js_value(x),
+    }
+}
+
+fn return_value_to_js_value(v: &wast::core::WastRetCore<'_>) -> Result<String> {
+    use wast::core::WastRetCore::*;
+    Ok(match v {
+        I32(x) => format!("value(\"i32\", {})", x),
+        I64(x) => format!("value(\"i64\", {}n)", x),
+        F32(x) => f32_pattern_to_js_value(x),
+        F64(x) => f64_pattern_to_js_value(x),
+        RefNull(x) => match x {
+            Some(wast::core::HeapType::Func) => format!("value('anyfunc', null)"),
+            Some(wast::core::HeapType::Extern) => format!("value('externref', null)"),
+            other => bail!(
+                "couldn't convert ref.null {:?} to a js assertion value",
+                other
+            ),
+        },
+        RefExtern(x) => format!("value('externref', externref({}))", x),
+        V128(x) => {
+            use wast::core::V128Pattern::*;
+            match x {
+                I8x16(elements) => format!(
+                    "i8x16({})",
+                    to_js_value_array_string(elements, |x| Ok(format!("0x{:x}", x)))?,
+                ),
+                I16x8(elements) => format!(
+                    "i16x8({})",
+                    to_js_value_array_string(elements, |x| Ok(format!("0x{:x}", x)))?,
+                ),
+                I32x4(elements) => format!(
+                    "i32x4({})",
+                    to_js_value_array_string(elements, |x| Ok(format!("0x{:x}", x)))?,
+                ),
+                I64x2(elements) => format!(
+                    "i64x2({})",
+                    to_js_value_array_string(elements, |x| Ok(format!("0x{:x}n", x)))?,
+                ),
+                F32x4(elements) => {
+                    let elements: Vec<String> = elements
+                        .iter()
+                        .map(|x| f32_pattern_to_js_value(x))
+                        .collect();
+                    let elements = strings_to_raws(elements);
+                    JSNode::Call {
+                        name: "new F32x4Pattern".to_string(),
+                        args: elements,
+                    }
+                    .output(0)
+                }
+                F64x2(elements) => {
+                    let elements: Vec<String> = elements
+                        .iter()
+                        .map(|x| f64_pattern_to_js_value(x))
+                        .collect();
+                    let elements = strings_to_raws(elements);
+                    JSNode::Call {
+                        name: "new F64x2Pattern".to_string(),
+                        args: elements,
+                    }
+                    .output(0)
+                }
+            }
+        }
+        Either(v) => {
+            let args = v
+                .iter()
+                .map(|v| return_value_to_js_value(v).unwrap())
+                .collect();
+            let args = strings_to_raws(args);
+            JSNode::Call {
+                name: "either".to_string(),
+                args: args,
+            }
+            .output(0)
+        }
+        other => bail!("couldn't convert Core({:?}) to a js assertion value", other),
+    })
+}
+
+fn assert_expression_to_js_value(v: &wast::WastRet<'_>) -> Result<String> {
+    use wast::WastRet::*;
+
+    Ok(match &v {
+        Core(x) => return_value_to_js_value(x)?,
+        other => bail!("couldn't convert {:?} to a js assertion value", other),
+    })
+}
+
+fn arg_to_js_value(v: &wast::WastArg<'_>) -> Result<String> {
+    use wast::core::WastArgCore::*;
+    use wast::WastArg::Core;
+
+    Ok(match &v {
+        Core(I32(x)) => format!("{}", *x),
+        Core(I64(x)) => format!("{}n", *x),
+        Core(F32(x)) => float32_to_js_value(x),
+        Core(F64(x)) => float64_to_js_value(x),
+        Core(V128(x)) => {
+            use wast::core::V128Const::*;
+            match x {
+                I8x16(elements) => format!(
+                    "i8x16({})",
+                    to_js_value_array_string(elements, |x| Ok(format!("0x{:x}", x)))?,
+                ),
+                I16x8(elements) => format!(
+                    "i16x8({})",
+                    to_js_value_array_string(elements, |x| Ok(format!("0x{:x}", x)))?,
+                ),
+                I32x4(elements) => format!(
+                    "i32x4({})",
+                    to_js_value_array_string(elements, |x| Ok(format!("0x{:x}", x)))?,
+                ),
+                I64x2(elements) => format!(
+                    "i64x2({})",
+                    to_js_value_array_string(elements, |x| Ok(format!("0x{:x}n", x)))?,
+                ),
+                F32x4(elements) => {
+                    if f32x4_needs_bits(elements) {
+                        let bytes =
+                            to_js_value_array(&x.to_le_bytes(), |x| Ok(format!("0x{:x}", x)))?;
+                        format!("bytes('v128', {})", bytes.output(0))
+                    } else {
+                        let vals = to_js_value_array(elements, |x| {
+                            Ok(f32_to_js_value(f32::from_bits(x.bits)))
+                        })?;
+                        format!("f32x4({})", vals.output(0))
+                    }
+                }
+                F64x2(elements) => {
+                    if f64x2_needs_bits(elements) {
+                        let bytes =
+                            to_js_value_array(&x.to_le_bytes(), |x| Ok(format!("0x{:x}", x)))?;
+                        format!("bytes('v128', {})", bytes.output(0))
+                    } else {
+                        let vals = to_js_value_array(elements, |x| {
+                            Ok(f64_to_js_value(f64::from_bits(x.bits)))
+                        })?;
+                        format!("f64x2({})", vals.output(0))
+                    }
+                }
+            }
+        }
+        Core(RefNull(_)) => format!("null"),
+        Core(RefExtern(x)) => format!("externref({})", x),
+        other => bail!("couldn't convert {:?} to a js value", other),
+    })
+}
diff --git a/js/src/jit-test/etc/wasm/generate-spectests/wast2js/src/harness.js b/js/src/jit-test/etc/wasm/generate-spectests/wast2js/src/harness.js
new file mode 100644
index 0000000000..ba615e05dd
--- /dev/null
+++ b/js/src/jit-test/etc/wasm/generate-spectests/wast2js/src/harness.js
@@ -0,0 +1,360 @@
+"use strict";
+
+/* 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.
+ */
+
+if (!wasmIsSupported()) {
+  quit();
+}
+
+function bytes(type, bytes) {
+  var typedBuffer = new Uint8Array(bytes);
+  return wasmGlobalFromArrayBuffer(type, typedBuffer.buffer);
+}
+function value(type, value) {
+  return new WebAssembly.Global({
+    value: type,
+    mutable: false,
+  }, value);
+}
+
+function i8x16(elements) {
+  let typedBuffer = new Uint8Array(elements);
+  return wasmGlobalFromArrayBuffer("v128", typedBuffer.buffer);
+}
+function i16x8(elements) {
+  let typedBuffer = new Uint16Array(elements);
+  return wasmGlobalFromArrayBuffer("v128", typedBuffer.buffer);
+}
+function i32x4(elements) {
+  let typedBuffer = new Uint32Array(elements);
+  return wasmGlobalFromArrayBuffer("v128", typedBuffer.buffer);
+}
+function i64x2(elements) {
+  let typedBuffer = new BigUint64Array(elements);
+  return wasmGlobalFromArrayBuffer("v128", typedBuffer.buffer);
+}
+function f32x4(elements) {
+  let typedBuffer = new Float32Array(elements);
+  return wasmGlobalFromArrayBuffer("v128", typedBuffer.buffer);
+}
+function f64x2(elements) {
+  let typedBuffer = new Float64Array(elements);
+  return wasmGlobalFromArrayBuffer("v128", typedBuffer.buffer);
+}
+
+function either(...arr) {
+  return new EitherVariants(arr);
+}
+
+class F32x4Pattern {
+  constructor(x, y, z, w) {
+    this.x = x;
+    this.y = y;
+    this.z = z;
+    this.w = w;
+  }
+}
+
+class F64x2Pattern {
+  constructor(x, y) {
+    this.x = x;
+    this.y = y;
+  }
+}
+
+let externrefs = {};
+let externsym = Symbol("externref");
+function externref(s) {
+  if (!(s in externrefs)) externrefs[s] = { [externsym]: s };
+  return externrefs[s];
+}
+function is_externref(x) {
+  return (x !== null && externsym in x) ? 1 : 0;
+}
+function is_funcref(x) {
+  return typeof x === "function" ? 1 : 0;
+}
+function eq_externref(x, y) {
+  return x === y ? 1 : 0;
+}
+function eq_funcref(x, y) {
+  return x === y ? 1 : 0;
+}
+
+let spectest = {
+  externref: externref,
+  is_externref: is_externref,
+  is_funcref: is_funcref,
+  eq_externref: eq_externref,
+  eq_funcref: eq_funcref,
+  print: console.log.bind(console),
+  print_i32: console.log.bind(console),
+  print_i32_f32: console.log.bind(console),
+  print_f64_f64: console.log.bind(console),
+  print_f32: console.log.bind(console),
+  print_f64: console.log.bind(console),
+  global_i32: 666,
+  global_i64: 666n,
+  global_f32: 666,
+  global_f64: 666,
+  table: new WebAssembly.Table({
+    initial: 10,
+    maximum: 20,
+    element: "anyfunc",
+  }),
+  memory: new WebAssembly.Memory({ initial: 1, maximum: 2 }),
+};
+
+let linkage = {
+  spectest,
+};
+
+function getInstance(instanceish) {
+  if (typeof instanceish === "string") {
+    assertEq(
+      instanceish in linkage,
+      true,
+      `'${instanceish}'' must be registered`,
+    );
+    return linkage[instanceish];
+  }
+  return instanceish;
+}
+
+function instantiate(source) {
+  let bytecode = wasmTextToBinary(source);
+  let module = new WebAssembly.Module(bytecode);
+  let instance = new WebAssembly.Instance(module, linkage);
+  return instance.exports;
+}
+
+function register(instanceish, name) {
+  linkage[name] = getInstance(instanceish);
+}
+
+function invoke(instanceish, field, params) {
+  let func = getInstance(instanceish)[field];
+  assertEq(func instanceof Function, true, "expected a function");
+  return wasmLosslessInvoke(func, ...params);
+}
+
+function get(instanceish, field) {
+  let global = getInstance(instanceish)[field];
+  assertEq(
+    global instanceof WebAssembly.Global,
+    true,
+    "expected a WebAssembly.Global",
+  );
+  return global;
+}
+
+function assert_trap(thunk, message) {
+  try {
+    thunk();
+    assertEq("normal return", "trap");
+  } catch (err) {
+    assertEq(
+      err instanceof WebAssembly.RuntimeError,
+      true,
+      "expected trap",
+    );
+  }
+}
+
+let StackOverflow;
+try {
+  (function f() {
+    1 + f();
+  })();
+} catch (e) {
+  StackOverflow = e.constructor;
+}
+function assert_exhaustion(thunk, message) {
+  try {
+    thunk();
+    assertEq("normal return", "exhaustion");
+  } catch (err) {
+    assertEq(
+      err instanceof StackOverflow,
+      true,
+      "expected exhaustion",
+    );
+  }
+}
+
+function assert_invalid(thunk, message) {
+  try {
+    thunk();
+    assertEq("valid module", "invalid module");
+  } catch (err) {
+    assertEq(
+      err instanceof WebAssembly.LinkError ||
+        err instanceof WebAssembly.CompileError,
+      true,
+      "expected an invalid module",
+    );
+  }
+}
+
+function assert_unlinkable(thunk, message) {
+  try {
+    thunk();
+    assertEq(true, false, "expected an unlinkable module");
+  } catch (err) {
+    assertEq(
+      err instanceof WebAssembly.LinkError ||
+        err instanceof WebAssembly.CompileError,
+      true,
+      "expected an unlinkable module",
+    );
+  }
+}
+
+function assert_malformed(thunk, message) {
+  try {
+    thunk();
+    assertEq("valid module", "malformed module");
+  } catch (err) {
+    assertEq(
+      err instanceof TypeError ||
+        err instanceof SyntaxError ||
+        err instanceof WebAssembly.CompileError ||
+        err instanceof WebAssembly.LinkError,
+      true,
+      `expected a malformed module`,
+    );
+  }
+}
+
+function assert_exception(thunk) {
+  let thrown = false;
+  try {
+    thunk();
+  } catch (err) {
+    thrown = true;
+  }
+  assertEq(thrown, true, "expected an exception to be thrown");
+}
+
+function assert_return(thunk, expected) {
+  let results = thunk();
+
+  if (results === undefined) {
+    results = [];
+  } else if (!Array.isArray(results)) {
+    results = [results];
+  }
+  if (!Array.isArray(expected)) {
+    expected = [expected];
+  }
+
+  if (!compareResults(results, expected)) {
+    let got = results.map((x) => formatResult(x)).join(", ");
+    let wanted = expected.map((x) => formatExpected(x)).join(", ");
+    assertEq(
+      `[${got}]`,
+      `[${wanted}]`,
+    );
+    assertEq(true, false, `${got} !== ${wanted}`);
+  }
+}
+
+function formatResult(result) {
+  if (typeof (result) === "object") {
+    return wasmGlobalToString(result);
+  } else {
+    return `${result}`;
+  }
+}
+
+function formatExpected(expected) {
+  if (
+    expected === `f32_canonical_nan` ||
+    expected === `f32_arithmetic_nan` ||
+    expected === `f64_canonical_nan` ||
+    expected === `f64_arithmetic_nan`
+  ) {
+    return expected;
+  } else if (expected instanceof F32x4Pattern) {
+    return `f32x4(${formatExpected(expected.x)}, ${
+      formatExpected(expected.y)
+    }, ${formatExpected(expected.z)}, ${formatExpected(expected.w)})`;
+  } else if (expected instanceof F64x2Pattern) {
+    return `f64x2(${formatExpected(expected.x)}, ${
+      formatExpected(expected.y)
+    })`;
+  } else if (expected instanceof EitherVariants) {
+    return expected.formatExpected();
+  } else if (typeof (expected) === "object") {
+    return wasmGlobalToString(expected);
+  } else {
+    throw new Error("unknown expected result");
+  }
+}
+
+class EitherVariants {
+  constructor(arr) {
+    this.arr = arr;
+  }
+  matches(v) {
+    return this.arr.some((e) => compareResult(v, e));
+  }
+  formatExpected() {
+    return `either(${this.arr.map(formatExpected).join(", ")})`;
+  }
+}
+
+function compareResults(results, expected) {
+  if (results.length !== expected.length) {
+    return false;
+  }
+  for (let i in results) {
+    if (expected[i] instanceof EitherVariants) {
+      return expected[i].matches(results[i]);
+    }
+    if (!compareResult(results[i], expected[i])) {
+      return false;
+    }
+  }
+  return true;
+}
+
+function compareResult(result, expected) {
+  if (
+    expected === `canonical_nan` ||
+    expected === `arithmetic_nan`
+  ) {
+    return wasmGlobalIsNaN(result, expected);
+  } else if (expected instanceof F32x4Pattern) {
+    return compareResult(
+      wasmGlobalExtractLane(result, "f32x4", 0),
+      expected.x,
+    ) &&
+      compareResult(wasmGlobalExtractLane(result, "f32x4", 1), expected.y) &&
+      compareResult(wasmGlobalExtractLane(result, "f32x4", 2), expected.z) &&
+      compareResult(wasmGlobalExtractLane(result, "f32x4", 3), expected.w);
+  } else if (expected instanceof F64x2Pattern) {
+    return compareResult(
+      wasmGlobalExtractLane(result, "f64x2", 0),
+      expected.x,
+    ) &&
+      compareResult(wasmGlobalExtractLane(result, "f64x2", 1), expected.y);
+  } else if (typeof (expected) === "object") {
+    return wasmGlobalsEqual(result, expected);
+  } else {
+    throw new Error("unknown expected result");
+  }
+}
diff --git a/js/src/jit-test/etc/wasm/generate-spectests/wast2js/src/lib.rs b/js/src/jit-test/etc/wasm/generate-spectests/wast2js/src/lib.rs
new file mode 100644
index 0000000000..b62bcbfaea
--- /dev/null
+++ b/js/src/jit-test/etc/wasm/generate-spectests/wast2js/src/lib.rs
@@ -0,0 +1,18 @@
+/* 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.
+ */
+
+mod convert;
+mod out;
+pub use convert::*;
diff --git a/js/src/jit-test/etc/wasm/generate-spectests/wast2js/src/license.js b/js/src/jit-test/etc/wasm/generate-spectests/wast2js/src/license.js
new file mode 100644
index 0000000000..12d51bd702
--- /dev/null
+++ b/js/src/jit-test/etc/wasm/generate-spectests/wast2js/src/license.js
@@ -0,0 +1,14 @@
+/* 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.
+ */
diff --git a/js/src/jit-test/etc/wasm/generate-spectests/wast2js/src/main.rs b/js/src/jit-test/etc/wasm/generate-spectests/wast2js/src/main.rs
new file mode 100644
index 0000000000..d5d1118e7e
--- /dev/null
+++ b/js/src/jit-test/etc/wasm/generate-spectests/wast2js/src/main.rs
@@ -0,0 +1,40 @@
+/* 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.
+ */
+
+use anyhow::{Context as _, Result};
+use std::env;
+use std::path::Path;
+
+mod convert;
+mod out;
+
+fn main() -> Result<()> {
+    let files = env::args().collect::<Vec<String>>();
+    for path in &files[1..] {
+        let source =
+            std::fs::read_to_string(path).with_context(|| format!("failed to read `{}`", path))?;
+
+        let mut full_script = String::new();
+        full_script.push_str(&convert::harness());
+        full_script.push_str(&convert::convert(path, &source)?);
+
+        std::fs::write(
+            Path::new(path).with_extension("js").file_name().unwrap(),
+            &full_script,
+        )?;
+    }
+
+    Ok(())
+}
diff --git a/js/src/jit-test/etc/wasm/generate-spectests/wast2js/src/out.rs b/js/src/jit-test/etc/wasm/generate-spectests/wast2js/src/out.rs
new file mode 100644
index 0000000000..1d47365f19
--- /dev/null
+++ b/js/src/jit-test/etc/wasm/generate-spectests/wast2js/src/out.rs
@@ -0,0 +1,180 @@
+/* Copyright 2022 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.
+ */
+
+/// This module has a bare-bones "syntax tree" that helps us output more readable JS code in our
+/// tests. This is a lot cheaper and faster than running a full JS formatter on the generated code.
+/// The tree only has node types for things that matter to formatting; most things in the output
+/// use the Raw type, which is just a plain old string.
+
+pub const LINE_WIDTH: usize = 80; // the default line width to try to meet (will not be met perfectly)
+pub const NOWRAP: usize = 1000; // use for line_remaining when you don't want to wrap text
+
+pub enum JSNode {
+    Assert {
+        name: String,
+        exec: Box<JSNode>,
+        expected: Box<JSNode>,
+    },
+    Invoke {
+        instance: String,
+        name: String,
+        body: Box<JSNode>,
+    },
+    Call {
+        name: String,
+        args: Vec<Box<JSNode>>,
+    },
+    Array(Vec<Box<JSNode>>),
+    Raw(String),
+}
+
+impl JSNode {
+    /// Converts a node to JavaScript code. line_remaining is the number of characters remaining on
+    /// the line, used for line-wrapping purposes; if zero, the default LINE_WIDTH will be used.
+    pub fn output(&self, line_remaining: usize) -> String {
+        let line_remaining = if line_remaining == 0 {
+            LINE_WIDTH
+        } else {
+            line_remaining
+        };
+        match self {
+            Self::Assert {
+                name,
+                exec,
+                expected,
+            } => {
+                if self.len() > line_remaining {
+                    format!(
+                        "{}(\n{}\n)",
+                        name,
+                        indent(format!(
+                            "() => {},\n{},",
+                            exec.output(line_remaining - 8),
+                            expected.output(line_remaining - 2),
+                        )),
+                    )
+                } else {
+                    format!(
+                        "{}(() => {}, {})",
+                        name,
+                        exec.output(NOWRAP),
+                        expected.output(NOWRAP),
+                    )
+                }
+            }
+            Self::Invoke {
+                instance,
+                name,
+                body,
+            } => {
+                let body_string =
+                    body.output(line_remaining - "invoke".len() - instance.len() - name.len());
+                format!("invoke({}, `{}`, {})", instance, name, body_string)
+            }
+            Self::Call { name, args } => {
+                if self.len() > line_remaining {
+                    let arg_strings: Vec<String> = args
+                        .iter()
+                        .map(|arg| arg.output(line_remaining - 2))
+                        .collect();
+                    format!("{}(\n{},\n)", name, indent(arg_strings.join(",\n")))
+                } else {
+                    let arg_strings: Vec<String> =
+                        args.iter().map(|arg| arg.output(NOWRAP)).collect();
+                    format!("{}({})", name, arg_strings.join(", "))
+                }
+            }
+            Self::Array(values) => {
+                if self.len() > line_remaining {
+                    let value_strings = output_nodes(&values, 70);
+                    format!("[\n{},\n]", indent(value_strings.join(",\n")))
+                } else {
+                    let value_strings = output_nodes(&values, 80);
+                    format!("[{}]", value_strings.join(", "))
+                }
+            }
+            Self::Raw(val) => val.to_string(),
+        }
+    }
+
+    /// A rough estimate of the string length of the node. Used as a heuristic to know when we
+    /// should wrap text.
+    fn len(&self) -> usize {
+        match self {
+            Self::Assert {
+                name,
+                exec,
+                expected,
+            } => name.len() + exec.len() + expected.len(),
+            Self::Invoke {
+                instance,
+                name,
+                body,
+            } => instance.len() + name.len() + body.len(),
+            Self::Call { name, args } => {
+                let mut args_len: usize = 0;
+                for node in args {
+                    args_len += node.len() + ", ".len();
+                }
+                name.len() + args_len
+            }
+            Self::Array(nodes) => {
+                let mut content_len: usize = 0;
+                for node in nodes {
+                    content_len += node.len() + ", ".len();
+                }
+                content_len
+            }
+            Self::Raw(s) => s.len(),
+        }
+    }
+}
+
+pub fn output_nodes(nodes: &Vec<Box<JSNode>>, line_width_per_node: usize) -> Vec<String> {
+    nodes
+        .iter()
+        .map(|node| node.output(line_width_per_node))
+        .collect()
+}
+
+pub fn strings_to_raws(strs: Vec<String>) -> Vec<Box<JSNode>> {
+    let mut res: Vec<Box<JSNode>> = vec![];
+    for s in strs {
+        res.push(Box::new(JSNode::Raw(s)));
+    }
+    res
+}
+
+fn indent(s: String) -> String {
+    let mut result = String::new();
+    let mut do_indent = true;
+    for (i, line) in s.lines().enumerate() {
+        if i > 0 {
+            result.push('\n');
+        }
+        if line.chars().any(|c| !c.is_whitespace()) {
+            if do_indent {
+                result.push_str("  ");
+            }
+            result.push_str(line);
+
+            // An odd number of backticks in the line means we are entering or exiting a raw string.
+            if line.matches("`").count() % 2 == 1 {
+                do_indent = !do_indent
+            }
+        }
+    }
+    result
+}
diff --git a/js/src/jit-test/etc/wasm/spec-tests.patch b/js/src/jit-test/etc/wasm/spec-tests.patch
new file mode 100644
index 0000000000..d0de76b1ab
--- /dev/null
+++ b/js/src/jit-test/etc/wasm/spec-tests.patch
@@ -0,0 +1,784 @@
+# HG changeset patch
+# User Ryan Hunt <rhunt@eqrion.net>
+# Date 1634962581 0
+#      Sat Oct 23 04:16:21 2021 +0000
+# Node ID 40a38b62293c892ef4e397c43179321edccea2c3
+# Parent  bb4199affde55df21fd07f2fbf65155bc60a0943
+Spec test patches rollup.
+
+1. Bug 1737225 - Disable some tests on arm.  r=yury
+
+Disable a partial-oob test on arm/arm64 because some hardware will
+perform byte-at-a-time writes at the end of the heap, and we have
+not fixed that yet.
+
+user: Lars Hansen
+Differential Revision: https://phabricator.services.mozilla.com/D129248
+
+2. Bug 1747450 - simd has moved to spec and needs per-test skips.
+user: Ryan Hunt
+
+diff --git a/js/src/jit-test/tests/wasm/spec/memory64/align64.wast.js b/js/src/jit-test/tests/wasm/spec/memory64/align64.wast.js
+--- a/js/src/jit-test/tests/wasm/spec/memory64/align64.wast.js
++++ b/js/src/jit-test/tests/wasm/spec/memory64/align64.wast.js
+@@ -1076,8 +1076,15 @@ let $24 = instantiate(`(module
+   )
+ )`);
+
+-// ./test/core/align64.wast:864
+-assert_trap(() => invoke($24, `store`, [65532n, -1n]), `out of bounds memory access`);
+-
+-// ./test/core/align64.wast:866
+-assert_return(() => invoke($24, `load`, [65532n]), [value("i32", 0)]);
++// Bug 1737225 - do not observe the partial store caused by bug 1666747 on
++// some native platforms.
++if (!partialOobWriteMayWritePartialData()) {
++    // ./test/core/align64.wast:864
++    assert_trap(
++        () => invoke($24, `store`, [65532n, -1n]),
++        `out of bounds memory access`,
++    );
++
++    // ./test/core/align64.wast:866
++    assert_return(() => invoke($24, `load`, [65532n]), [value("i32", 0)]);
++}
+diff --git a/js/src/jit-test/tests/wasm/spec/memory64/harness/harness.js b/js/src/jit-test/tests/wasm/spec/memory64/harness/harness.js
+--- a/js/src/jit-test/tests/wasm/spec/memory64/harness/harness.js
++++ b/js/src/jit-test/tests/wasm/spec/memory64/harness/harness.js
+@@ -19,6 +19,17 @@ if (!wasmIsSupported()) {
+   quit();
+ }
+ 
++function partialOobWriteMayWritePartialData() {
++    let cfg = getBuildConfiguration();
++    let arm_native = cfg["arm"] && !cfg["arm-simulator"];
++    let arm64_native = cfg["arm64"] && !cfg["arm64-simulator"];
++    return arm_native || arm64_native;
++}
++
++let cfg = getBuildConfiguration();
++let native_arm = cfg["arm"] && !cfg["arm-simulator"];
++let native_arm64 = cfg["arm64"] && !cfg["arm64-simulator"];
++
+ function bytes(type, bytes) {
+   var typedBuffer = new Uint8Array(bytes);
+   return wasmGlobalFromArrayBuffer(type, typedBuffer.buffer);
+diff --git a/js/src/jit-test/tests/wasm/spec/memory64/memory_trap64.wast.js b/js/src/jit-test/tests/wasm/spec/memory64/memory_trap64.wast.js
+--- a/js/src/jit-test/tests/wasm/spec/memory64/memory_trap64.wast.js
++++ b/js/src/jit-test/tests/wasm/spec/memory64/memory_trap64.wast.js
+@@ -617,8 +617,16 @@ assert_trap(() => invoke($1, `i64.load32_u`, [-3n]), `out of bounds memory acces
+ // ./test/core/memory_trap64.wast:265
+ assert_trap(() => invoke($1, `i64.load32_u`, [-4n]), `out of bounds memory access`);
+ 
+-// ./test/core/memory_trap64.wast:268
+-assert_return(() => invoke($1, `i64.load`, [65528n]), [value("i64", 7523094288207667809n)]);
+-
+-// ./test/core/memory_trap64.wast:269
+-assert_return(() => invoke($1, `i64.load`, [0n]), [value("i64", 7523094288207667809n)]);
++// Bug 1737225 - do not observe the partial store caused by bug 1666747 on
++// some native platforms.
++if (!partialOobWriteMayWritePartialData()) {
++    // ./test/core/memory_trap64.wast:268
++    assert_return(() => invoke($1, `i64.load`, [65528n]), [
++        value("i64", 7523094288207667809n),
++    ]);
++
++    // ./test/core/memory_trap64.wast:269
++    assert_return(() => invoke($1, `i64.load`, [0n]), [
++        value("i64", 7523094288207667809n),
++    ]);
++}
+diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_address.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_address.wast.js
+--- a/js/src/jit-test/tests/wasm/spec/spec/simd_address.wast.js
++++ b/js/src/jit-test/tests/wasm/spec/spec/simd_address.wast.js
+@@ -1,3 +1,5 @@
++// |jit-test| skip-if: !wasmSimdEnabled()
++
+ /* Copyright 2021 Mozilla Foundation
+  *
+  * Licensed under the Apache License, Version 2.0 (the "License");
+diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_bit_shift.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_bit_shift.wast.js
+--- a/js/src/jit-test/tests/wasm/spec/spec/simd_bit_shift.wast.js
++++ b/js/src/jit-test/tests/wasm/spec/spec/simd_bit_shift.wast.js
+@@ -1,3 +1,5 @@
++// |jit-test| skip-if: !wasmSimdEnabled()
++
+ /* Copyright 2021 Mozilla Foundation
+  *
+  * Licensed under the Apache License, Version 2.0 (the "License");
+diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_bitwise.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_bitwise.wast.js
+--- a/js/src/jit-test/tests/wasm/spec/spec/simd_bitwise.wast.js
++++ b/js/src/jit-test/tests/wasm/spec/spec/simd_bitwise.wast.js
+@@ -1,3 +1,5 @@
++// |jit-test| skip-if: !wasmSimdEnabled()
++
+ /* Copyright 2021 Mozilla Foundation
+  *
+  * Licensed under the Apache License, Version 2.0 (the "License");
+diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_boolean.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_boolean.wast.js
+--- a/js/src/jit-test/tests/wasm/spec/spec/simd_boolean.wast.js
++++ b/js/src/jit-test/tests/wasm/spec/spec/simd_boolean.wast.js
+@@ -1,3 +1,5 @@
++// |jit-test| skip-if: !wasmSimdEnabled()
++
+ /* Copyright 2021 Mozilla Foundation
+  *
+  * Licensed under the Apache License, Version 2.0 (the "License");
+diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_const.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_const.wast.js
+--- a/js/src/jit-test/tests/wasm/spec/spec/simd_const.wast.js
++++ b/js/src/jit-test/tests/wasm/spec/spec/simd_const.wast.js
+@@ -1,3 +1,5 @@
++// |jit-test| skip-if: !wasmSimdEnabled()
++
+ /* Copyright 2021 Mozilla Foundation
+  *
+  * Licensed under the Apache License, Version 2.0 (the "License");
+diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_conversions.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_conversions.wast.js
+--- a/js/src/jit-test/tests/wasm/spec/spec/simd_conversions.wast.js
++++ b/js/src/jit-test/tests/wasm/spec/spec/simd_conversions.wast.js
+@@ -1,3 +1,5 @@
++// |jit-test| skip-if: !wasmSimdEnabled()
++
+ /* Copyright 2021 Mozilla Foundation
+  *
+  * Licensed under the Apache License, Version 2.0 (the "License");
+diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_f32x4.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_f32x4.wast.js
+--- a/js/src/jit-test/tests/wasm/spec/spec/simd_f32x4.wast.js
++++ b/js/src/jit-test/tests/wasm/spec/spec/simd_f32x4.wast.js
+@@ -1,3 +1,5 @@
++// |jit-test| skip-if: !wasmSimdEnabled()
++
+ /* Copyright 2021 Mozilla Foundation
+  *
+  * Licensed under the Apache License, Version 2.0 (the "License");
+diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_f32x4_arith.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_f32x4_arith.wast.js
+--- a/js/src/jit-test/tests/wasm/spec/spec/simd_f32x4_arith.wast.js
++++ b/js/src/jit-test/tests/wasm/spec/spec/simd_f32x4_arith.wast.js
+@@ -1,3 +1,5 @@
++// |jit-test| skip-if: !wasmSimdEnabled()
++
+ /* Copyright 2021 Mozilla Foundation
+  *
+  * Licensed under the Apache License, Version 2.0 (the "License");
+diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_f32x4_cmp.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_f32x4_cmp.wast.js
+--- a/js/src/jit-test/tests/wasm/spec/spec/simd_f32x4_cmp.wast.js
++++ b/js/src/jit-test/tests/wasm/spec/spec/simd_f32x4_cmp.wast.js
+@@ -1,3 +1,5 @@
++// |jit-test| skip-if: !wasmSimdEnabled()
++
+ /* Copyright 2021 Mozilla Foundation
+  *
+  * Licensed under the Apache License, Version 2.0 (the "License");
+diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_f32x4_pmin_pmax.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_f32x4_pmin_pmax.wast.js
+--- a/js/src/jit-test/tests/wasm/spec/spec/simd_f32x4_pmin_pmax.wast.js
++++ b/js/src/jit-test/tests/wasm/spec/spec/simd_f32x4_pmin_pmax.wast.js
+@@ -1,3 +1,5 @@
++// |jit-test| skip-if: !wasmSimdEnabled()
++
+ /* Copyright 2021 Mozilla Foundation
+  *
+  * Licensed under the Apache License, Version 2.0 (the "License");
+diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_f32x4_rounding.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_f32x4_rounding.wast.js
+--- a/js/src/jit-test/tests/wasm/spec/spec/simd_f32x4_rounding.wast.js
++++ b/js/src/jit-test/tests/wasm/spec/spec/simd_f32x4_rounding.wast.js
+@@ -1,3 +1,5 @@
++// |jit-test| skip-if: !wasmSimdEnabled()
++
+ /* Copyright 2021 Mozilla Foundation
+  *
+  * Licensed under the Apache License, Version 2.0 (the "License");
+diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_f64x2.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_f64x2.wast.js
+--- a/js/src/jit-test/tests/wasm/spec/spec/simd_f64x2.wast.js
++++ b/js/src/jit-test/tests/wasm/spec/spec/simd_f64x2.wast.js
+@@ -1,3 +1,5 @@
++// |jit-test| skip-if: !wasmSimdEnabled()
++
+ /* Copyright 2021 Mozilla Foundation
+  *
+  * Licensed under the Apache License, Version 2.0 (the "License");
+diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_f64x2_arith.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_f64x2_arith.wast.js
+--- a/js/src/jit-test/tests/wasm/spec/spec/simd_f64x2_arith.wast.js
++++ b/js/src/jit-test/tests/wasm/spec/spec/simd_f64x2_arith.wast.js
+@@ -1,3 +1,5 @@
++// |jit-test| skip-if: !wasmSimdEnabled()
++
+ /* Copyright 2021 Mozilla Foundation
+  *
+  * Licensed under the Apache License, Version 2.0 (the "License");
+diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_f64x2_cmp.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_f64x2_cmp.wast.js
+--- a/js/src/jit-test/tests/wasm/spec/spec/simd_f64x2_cmp.wast.js
++++ b/js/src/jit-test/tests/wasm/spec/spec/simd_f64x2_cmp.wast.js
+@@ -1,3 +1,5 @@
++// |jit-test| skip-if: !wasmSimdEnabled()
++
+ /* Copyright 2021 Mozilla Foundation
+  *
+  * Licensed under the Apache License, Version 2.0 (the "License");
+diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_f64x2_pmin_pmax.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_f64x2_pmin_pmax.wast.js
+--- a/js/src/jit-test/tests/wasm/spec/spec/simd_f64x2_pmin_pmax.wast.js
++++ b/js/src/jit-test/tests/wasm/spec/spec/simd_f64x2_pmin_pmax.wast.js
+@@ -1,3 +1,5 @@
++// |jit-test| skip-if: !wasmSimdEnabled()
++
+ /* Copyright 2021 Mozilla Foundation
+  *
+  * Licensed under the Apache License, Version 2.0 (the "License");
+diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_f64x2_rounding.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_f64x2_rounding.wast.js
+--- a/js/src/jit-test/tests/wasm/spec/spec/simd_f64x2_rounding.wast.js
++++ b/js/src/jit-test/tests/wasm/spec/spec/simd_f64x2_rounding.wast.js
+@@ -1,3 +1,5 @@
++// |jit-test| skip-if: !wasmSimdEnabled()
++
+ /* Copyright 2021 Mozilla Foundation
+  *
+  * Licensed under the Apache License, Version 2.0 (the "License");
+diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_i16x8_arith.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_i16x8_arith.wast.js
+--- a/js/src/jit-test/tests/wasm/spec/spec/simd_i16x8_arith.wast.js
++++ b/js/src/jit-test/tests/wasm/spec/spec/simd_i16x8_arith.wast.js
+@@ -1,3 +1,5 @@
++// |jit-test| skip-if: !wasmSimdEnabled()
++
+ /* Copyright 2021 Mozilla Foundation
+  *
+  * Licensed under the Apache License, Version 2.0 (the "License");
+diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_i16x8_arith2.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_i16x8_arith2.wast.js
+--- a/js/src/jit-test/tests/wasm/spec/spec/simd_i16x8_arith2.wast.js
++++ b/js/src/jit-test/tests/wasm/spec/spec/simd_i16x8_arith2.wast.js
+@@ -1,3 +1,5 @@
++// |jit-test| skip-if: !wasmSimdEnabled()
++
+ /* Copyright 2021 Mozilla Foundation
+  *
+  * Licensed under the Apache License, Version 2.0 (the "License");
+diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_i16x8_cmp.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_i16x8_cmp.wast.js
+--- a/js/src/jit-test/tests/wasm/spec/spec/simd_i16x8_cmp.wast.js
++++ b/js/src/jit-test/tests/wasm/spec/spec/simd_i16x8_cmp.wast.js
+@@ -1,3 +1,5 @@
++// |jit-test| skip-if: !wasmSimdEnabled()
++
+ /* Copyright 2021 Mozilla Foundation
+  *
+  * Licensed under the Apache License, Version 2.0 (the "License");
+diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_i16x8_extadd_pairwise_i8x16.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_i16x8_extadd_pairwise_i8x16.wast.js
+--- a/js/src/jit-test/tests/wasm/spec/spec/simd_i16x8_extadd_pairwise_i8x16.wast.js
++++ b/js/src/jit-test/tests/wasm/spec/spec/simd_i16x8_extadd_pairwise_i8x16.wast.js
+@@ -1,3 +1,5 @@
++// |jit-test| skip-if: !wasmSimdEnabled()
++
+ /* Copyright 2021 Mozilla Foundation
+  *
+  * Licensed under the Apache License, Version 2.0 (the "License");
+diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_i16x8_extmul_i8x16.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_i16x8_extmul_i8x16.wast.js
+--- a/js/src/jit-test/tests/wasm/spec/spec/simd_i16x8_extmul_i8x16.wast.js
++++ b/js/src/jit-test/tests/wasm/spec/spec/simd_i16x8_extmul_i8x16.wast.js
+@@ -1,3 +1,5 @@
++// |jit-test| skip-if: !wasmSimdEnabled()
++
+ /* Copyright 2021 Mozilla Foundation
+  *
+  * Licensed under the Apache License, Version 2.0 (the "License");
+diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_i16x8_q15mulr_sat_s.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_i16x8_q15mulr_sat_s.wast.js
+--- a/js/src/jit-test/tests/wasm/spec/spec/simd_i16x8_q15mulr_sat_s.wast.js
++++ b/js/src/jit-test/tests/wasm/spec/spec/simd_i16x8_q15mulr_sat_s.wast.js
+@@ -1,3 +1,5 @@
++// |jit-test| skip-if: !wasmSimdEnabled()
++
+ /* Copyright 2021 Mozilla Foundation
+  *
+  * Licensed under the Apache License, Version 2.0 (the "License");
+diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_i16x8_sat_arith.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_i16x8_sat_arith.wast.js
+--- a/js/src/jit-test/tests/wasm/spec/spec/simd_i16x8_sat_arith.wast.js
++++ b/js/src/jit-test/tests/wasm/spec/spec/simd_i16x8_sat_arith.wast.js
+@@ -1,3 +1,5 @@
++// |jit-test| skip-if: !wasmSimdEnabled()
++
+ /* Copyright 2021 Mozilla Foundation
+  *
+  * Licensed under the Apache License, Version 2.0 (the "License");
+diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_i32x4_arith.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_i32x4_arith.wast.js
+--- a/js/src/jit-test/tests/wasm/spec/spec/simd_i32x4_arith.wast.js
++++ b/js/src/jit-test/tests/wasm/spec/spec/simd_i32x4_arith.wast.js
+@@ -1,3 +1,5 @@
++// |jit-test| skip-if: !wasmSimdEnabled()
++
+ /* Copyright 2021 Mozilla Foundation
+  *
+  * Licensed under the Apache License, Version 2.0 (the "License");
+diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_i32x4_arith2.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_i32x4_arith2.wast.js
+--- a/js/src/jit-test/tests/wasm/spec/spec/simd_i32x4_arith2.wast.js
++++ b/js/src/jit-test/tests/wasm/spec/spec/simd_i32x4_arith2.wast.js
+@@ -1,3 +1,5 @@
++// |jit-test| skip-if: !wasmSimdEnabled()
++
+ /* Copyright 2021 Mozilla Foundation
+  *
+  * Licensed under the Apache License, Version 2.0 (the "License");
+diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_i32x4_cmp.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_i32x4_cmp.wast.js
+--- a/js/src/jit-test/tests/wasm/spec/spec/simd_i32x4_cmp.wast.js
++++ b/js/src/jit-test/tests/wasm/spec/spec/simd_i32x4_cmp.wast.js
+@@ -1,3 +1,5 @@
++// |jit-test| skip-if: !wasmSimdEnabled()
++
+ /* Copyright 2021 Mozilla Foundation
+  *
+  * Licensed under the Apache License, Version 2.0 (the "License");
+diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_i32x4_dot_i16x8.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_i32x4_dot_i16x8.wast.js
+--- a/js/src/jit-test/tests/wasm/spec/spec/simd_i32x4_dot_i16x8.wast.js
++++ b/js/src/jit-test/tests/wasm/spec/spec/simd_i32x4_dot_i16x8.wast.js
+@@ -1,3 +1,5 @@
++// |jit-test| skip-if: !wasmSimdEnabled()
++
+ /* Copyright 2021 Mozilla Foundation
+  *
+  * Licensed under the Apache License, Version 2.0 (the "License");
+diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_i32x4_extadd_pairwise_i16x8.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_i32x4_extadd_pairwise_i16x8.wast.js
+--- a/js/src/jit-test/tests/wasm/spec/spec/simd_i32x4_extadd_pairwise_i16x8.wast.js
++++ b/js/src/jit-test/tests/wasm/spec/spec/simd_i32x4_extadd_pairwise_i16x8.wast.js
+@@ -1,3 +1,5 @@
++// |jit-test| skip-if: !wasmSimdEnabled()
++
+ /* Copyright 2021 Mozilla Foundation
+  *
+  * Licensed under the Apache License, Version 2.0 (the "License");
+diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_i32x4_extmul_i16x8.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_i32x4_extmul_i16x8.wast.js
+--- a/js/src/jit-test/tests/wasm/spec/spec/simd_i32x4_extmul_i16x8.wast.js
++++ b/js/src/jit-test/tests/wasm/spec/spec/simd_i32x4_extmul_i16x8.wast.js
+@@ -1,3 +1,5 @@
++// |jit-test| skip-if: !wasmSimdEnabled()
++
+ /* Copyright 2021 Mozilla Foundation
+  *
+  * Licensed under the Apache License, Version 2.0 (the "License");
+diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_i32x4_trunc_sat_f32x4.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_i32x4_trunc_sat_f32x4.wast.js
+--- a/js/src/jit-test/tests/wasm/spec/spec/simd_i32x4_trunc_sat_f32x4.wast.js
++++ b/js/src/jit-test/tests/wasm/spec/spec/simd_i32x4_trunc_sat_f32x4.wast.js
+@@ -1,3 +1,5 @@
++// |jit-test| skip-if: !wasmSimdEnabled()
++
+ /* Copyright 2021 Mozilla Foundation
+  *
+  * Licensed under the Apache License, Version 2.0 (the "License");
+diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_i32x4_trunc_sat_f64x2.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_i32x4_trunc_sat_f64x2.wast.js
+--- a/js/src/jit-test/tests/wasm/spec/spec/simd_i32x4_trunc_sat_f64x2.wast.js
++++ b/js/src/jit-test/tests/wasm/spec/spec/simd_i32x4_trunc_sat_f64x2.wast.js
+@@ -1,3 +1,5 @@
++// |jit-test| skip-if: !wasmSimdEnabled()
++
+ /* Copyright 2021 Mozilla Foundation
+  *
+  * Licensed under the Apache License, Version 2.0 (the "License");
+diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_i64x2_arith.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_i64x2_arith.wast.js
+--- a/js/src/jit-test/tests/wasm/spec/spec/simd_i64x2_arith.wast.js
++++ b/js/src/jit-test/tests/wasm/spec/spec/simd_i64x2_arith.wast.js
+@@ -1,3 +1,5 @@
++// |jit-test| skip-if: !wasmSimdEnabled()
++
+ /* Copyright 2021 Mozilla Foundation
+  *
+  * Licensed under the Apache License, Version 2.0 (the "License");
+diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_i64x2_arith2.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_i64x2_arith2.wast.js
+--- a/js/src/jit-test/tests/wasm/spec/spec/simd_i64x2_arith2.wast.js
++++ b/js/src/jit-test/tests/wasm/spec/spec/simd_i64x2_arith2.wast.js
+@@ -1,3 +1,5 @@
++// |jit-test| skip-if: !wasmSimdEnabled()
++
+ /* Copyright 2021 Mozilla Foundation
+  *
+  * Licensed under the Apache License, Version 2.0 (the "License");
+diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_i64x2_cmp.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_i64x2_cmp.wast.js
+--- a/js/src/jit-test/tests/wasm/spec/spec/simd_i64x2_cmp.wast.js
++++ b/js/src/jit-test/tests/wasm/spec/spec/simd_i64x2_cmp.wast.js
+@@ -1,3 +1,5 @@
++// |jit-test| skip-if: !wasmSimdEnabled()
++
+ /* Copyright 2021 Mozilla Foundation
+  *
+  * Licensed under the Apache License, Version 2.0 (the "License");
+diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_i64x2_extmul_i32x4.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_i64x2_extmul_i32x4.wast.js
+--- a/js/src/jit-test/tests/wasm/spec/spec/simd_i64x2_extmul_i32x4.wast.js
++++ b/js/src/jit-test/tests/wasm/spec/spec/simd_i64x2_extmul_i32x4.wast.js
+@@ -1,3 +1,5 @@
++// |jit-test| skip-if: !wasmSimdEnabled()
++
+ /* Copyright 2021 Mozilla Foundation
+  *
+  * Licensed under the Apache License, Version 2.0 (the "License");
+diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_i8x16_arith.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_i8x16_arith.wast.js
+--- a/js/src/jit-test/tests/wasm/spec/spec/simd_i8x16_arith.wast.js
++++ b/js/src/jit-test/tests/wasm/spec/spec/simd_i8x16_arith.wast.js
+@@ -1,3 +1,5 @@
++// |jit-test| skip-if: !wasmSimdEnabled()
++
+ /* Copyright 2021 Mozilla Foundation
+  *
+  * Licensed under the Apache License, Version 2.0 (the "License");
+diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_i8x16_arith2.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_i8x16_arith2.wast.js
+--- a/js/src/jit-test/tests/wasm/spec/spec/simd_i8x16_arith2.wast.js
++++ b/js/src/jit-test/tests/wasm/spec/spec/simd_i8x16_arith2.wast.js
+@@ -1,3 +1,5 @@
++// |jit-test| skip-if: !wasmSimdEnabled()
++
+ /* Copyright 2021 Mozilla Foundation
+  *
+  * Licensed under the Apache License, Version 2.0 (the "License");
+diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_i8x16_cmp.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_i8x16_cmp.wast.js
+--- a/js/src/jit-test/tests/wasm/spec/spec/simd_i8x16_cmp.wast.js
++++ b/js/src/jit-test/tests/wasm/spec/spec/simd_i8x16_cmp.wast.js
+@@ -1,3 +1,5 @@
++// |jit-test| skip-if: !wasmSimdEnabled()
++
+ /* Copyright 2021 Mozilla Foundation
+  *
+  * Licensed under the Apache License, Version 2.0 (the "License");
+diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_i8x16_sat_arith.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_i8x16_sat_arith.wast.js
+--- a/js/src/jit-test/tests/wasm/spec/spec/simd_i8x16_sat_arith.wast.js
++++ b/js/src/jit-test/tests/wasm/spec/spec/simd_i8x16_sat_arith.wast.js
+@@ -1,3 +1,5 @@
++// |jit-test| skip-if: !wasmSimdEnabled()
++
+ /* Copyright 2021 Mozilla Foundation
+  *
+  * Licensed under the Apache License, Version 2.0 (the "License");
+diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_int_to_int_extend.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_int_to_int_extend.wast.js
+--- a/js/src/jit-test/tests/wasm/spec/spec/simd_int_to_int_extend.wast.js
++++ b/js/src/jit-test/tests/wasm/spec/spec/simd_int_to_int_extend.wast.js
+@@ -1,3 +1,5 @@
++// |jit-test| skip-if: !wasmSimdEnabled()
++
+ /* Copyright 2021 Mozilla Foundation
+  *
+  * Licensed under the Apache License, Version 2.0 (the "License");
+diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_lane.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_lane.wast.js
+--- a/js/src/jit-test/tests/wasm/spec/spec/simd_lane.wast.js
++++ b/js/src/jit-test/tests/wasm/spec/spec/simd_lane.wast.js
+@@ -1,3 +1,5 @@
++// |jit-test| skip-if: !wasmSimdEnabled()
++
+ /* Copyright 2021 Mozilla Foundation
+  *
+  * Licensed under the Apache License, Version 2.0 (the "License");
+diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_load.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_load.wast.js
+--- a/js/src/jit-test/tests/wasm/spec/spec/simd_load.wast.js
++++ b/js/src/jit-test/tests/wasm/spec/spec/simd_load.wast.js
+@@ -1,3 +1,5 @@
++// |jit-test| skip-if: !wasmSimdEnabled()
++
+ /* Copyright 2021 Mozilla Foundation
+  *
+  * Licensed under the Apache License, Version 2.0 (the "License");
+diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_load16_lane.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_load16_lane.wast.js
+--- a/js/src/jit-test/tests/wasm/spec/spec/simd_load16_lane.wast.js
++++ b/js/src/jit-test/tests/wasm/spec/spec/simd_load16_lane.wast.js
+@@ -1,3 +1,5 @@
++// |jit-test| skip-if: !wasmSimdEnabled()
++
+ /* Copyright 2021 Mozilla Foundation
+  *
+  * Licensed under the Apache License, Version 2.0 (the "License");
+diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_load32_lane.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_load32_lane.wast.js
+--- a/js/src/jit-test/tests/wasm/spec/spec/simd_load32_lane.wast.js
++++ b/js/src/jit-test/tests/wasm/spec/spec/simd_load32_lane.wast.js
+@@ -1,3 +1,5 @@
++// |jit-test| skip-if: !wasmSimdEnabled()
++
+ /* Copyright 2021 Mozilla Foundation
+  *
+  * Licensed under the Apache License, Version 2.0 (the "License");
+diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_load64_lane.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_load64_lane.wast.js
+--- a/js/src/jit-test/tests/wasm/spec/spec/simd_load64_lane.wast.js
++++ b/js/src/jit-test/tests/wasm/spec/spec/simd_load64_lane.wast.js
+@@ -1,3 +1,5 @@
++// |jit-test| skip-if: !wasmSimdEnabled()
++
+ /* Copyright 2021 Mozilla Foundation
+  *
+  * Licensed under the Apache License, Version 2.0 (the "License");
+diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_load8_lane.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_load8_lane.wast.js
+--- a/js/src/jit-test/tests/wasm/spec/spec/simd_load8_lane.wast.js
++++ b/js/src/jit-test/tests/wasm/spec/spec/simd_load8_lane.wast.js
+@@ -1,3 +1,5 @@
++// |jit-test| skip-if: !wasmSimdEnabled()
++
+ /* Copyright 2021 Mozilla Foundation
+  *
+  * Licensed under the Apache License, Version 2.0 (the "License");
+diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_load_extend.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_load_extend.wast.js
+--- a/js/src/jit-test/tests/wasm/spec/spec/simd_load_extend.wast.js
++++ b/js/src/jit-test/tests/wasm/spec/spec/simd_load_extend.wast.js
+@@ -1,3 +1,5 @@
++// |jit-test| skip-if: !wasmSimdEnabled()
++
+ /* Copyright 2021 Mozilla Foundation
+  *
+  * Licensed under the Apache License, Version 2.0 (the "License");
+diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_load_splat.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_load_splat.wast.js
+--- a/js/src/jit-test/tests/wasm/spec/spec/simd_load_splat.wast.js
++++ b/js/src/jit-test/tests/wasm/spec/spec/simd_load_splat.wast.js
+@@ -1,3 +1,5 @@
++// |jit-test| skip-if: !wasmSimdEnabled()
++
+ /* Copyright 2021 Mozilla Foundation
+  *
+  * Licensed under the Apache License, Version 2.0 (the "License");
+diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_load_zero.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_load_zero.wast.js
+--- a/js/src/jit-test/tests/wasm/spec/spec/simd_load_zero.wast.js
++++ b/js/src/jit-test/tests/wasm/spec/spec/simd_load_zero.wast.js
+@@ -1,3 +1,5 @@
++// |jit-test| skip-if: !wasmSimdEnabled()
++
+ /* Copyright 2021 Mozilla Foundation
+  *
+  * Licensed under the Apache License, Version 2.0 (the "License");
+diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_splat.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_splat.wast.js
+--- a/js/src/jit-test/tests/wasm/spec/spec/simd_splat.wast.js
++++ b/js/src/jit-test/tests/wasm/spec/spec/simd_splat.wast.js
+@@ -1,3 +1,5 @@
++// |jit-test| skip-if: !wasmSimdEnabled()
++
+ /* Copyright 2021 Mozilla Foundation
+  *
+  * Licensed under the Apache License, Version 2.0 (the "License");
+diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_store.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_store.wast.js
+--- a/js/src/jit-test/tests/wasm/spec/spec/simd_store.wast.js
++++ b/js/src/jit-test/tests/wasm/spec/spec/simd_store.wast.js
+@@ -1,3 +1,5 @@
++// |jit-test| skip-if: !wasmSimdEnabled()
++
+ /* Copyright 2021 Mozilla Foundation
+  *
+  * Licensed under the Apache License, Version 2.0 (the "License");
+diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_store16_lane.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_store16_lane.wast.js
+--- a/js/src/jit-test/tests/wasm/spec/spec/simd_store16_lane.wast.js
++++ b/js/src/jit-test/tests/wasm/spec/spec/simd_store16_lane.wast.js
+@@ -1,3 +1,5 @@
++// |jit-test| skip-if: !wasmSimdEnabled()
++
+ /* Copyright 2021 Mozilla Foundation
+  *
+  * Licensed under the Apache License, Version 2.0 (the "License");
+diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_store32_lane.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_store32_lane.wast.js
+--- a/js/src/jit-test/tests/wasm/spec/spec/simd_store32_lane.wast.js
++++ b/js/src/jit-test/tests/wasm/spec/spec/simd_store32_lane.wast.js
+@@ -1,3 +1,5 @@
++// |jit-test| skip-if: !wasmSimdEnabled()
++
+ /* Copyright 2021 Mozilla Foundation
+  *
+  * Licensed under the Apache License, Version 2.0 (the "License");
+diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_store64_lane.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_store64_lane.wast.js
+--- a/js/src/jit-test/tests/wasm/spec/spec/simd_store64_lane.wast.js
++++ b/js/src/jit-test/tests/wasm/spec/spec/simd_store64_lane.wast.js
+@@ -1,3 +1,5 @@
++// |jit-test| skip-if: !wasmSimdEnabled()
++
+ /* Copyright 2021 Mozilla Foundation
+  *
+  * Licensed under the Apache License, Version 2.0 (the "License");
+diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_store8_lane.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_store8_lane.wast.js
+--- a/js/src/jit-test/tests/wasm/spec/spec/simd_store8_lane.wast.js
++++ b/js/src/jit-test/tests/wasm/spec/spec/simd_store8_lane.wast.js
+@@ -1,3 +1,5 @@
++// |jit-test| skip-if: !wasmSimdEnabled()
++
+ /* Copyright 2021 Mozilla Foundation
+  *
+  * Licensed under the Apache License, Version 2.0 (the "License");
+diff --git a/js/src/jit-test/tests/wasm/spec/function-references/call_ref.wast.js b/js/src/jit-test/tests/wasm/spec/function-references/call_ref.wast.js
+TODO non-nullable references not supported in globals
+--- a/js/src/jit-test/tests/wasm/spec/function-references/call_ref.wast.js
++++ b/js/src/jit-test/tests/wasm/spec/function-references/call_ref.wast.js
+@@ -39,74 +39,6 @@ let $0 = instantiate(`(module
+   (func (export "null") (result i32)
+     (call_ref $$ii (i32.const 1) (ref.null $$ii))
+   )
+-
+-  ;; Recursion
+-
+-  (type $$ll (func (param i64) (result i64)))
+-  (type $$lll (func (param i64 i64) (result i64)))
+-
+-  (elem declare func $$fac)
+-  (global $$fac (ref $$ll) (ref.func $$fac))
+-
+-  (func $$fac (export "fac") (type $$ll)
+-    (if (result i64) (i64.eqz (local.get 0))
+-      (then (i64.const 1))
+-      (else
+-        (i64.mul
+-          (local.get 0)
+-          (call_ref $$ll (i64.sub (local.get 0) (i64.const 1)) (global.get $$fac))
+-        )
+-      )
+-    )
+-  )
+-
+-  (elem declare func $$fac-acc)
+-  (global $$fac-acc (ref $$lll) (ref.func $$fac-acc))
+-
+-  (func $$fac-acc (export "fac-acc") (type $$lll)
+-    (if (result i64) (i64.eqz (local.get 0))
+-      (then (local.get 1))
+-      (else
+-        (call_ref $$lll
+-          (i64.sub (local.get 0) (i64.const 1))
+-          (i64.mul (local.get 0) (local.get 1))
+-          (global.get $$fac-acc)
+-        )
+-      )
+-    )
+-  )
+-
+-  (elem declare func $$fib)
+-  (global $$fib (ref $$ll) (ref.func $$fib))
+-
+-  (func $$fib (export "fib") (type $$ll)
+-    (if (result i64) (i64.le_u (local.get 0) (i64.const 1))
+-      (then (i64.const 1))
+-      (else
+-        (i64.add
+-          (call_ref $$ll (i64.sub (local.get 0) (i64.const 2)) (global.get $$fib))
+-          (call_ref $$ll (i64.sub (local.get 0) (i64.const 1)) (global.get $$fib))
+-        )
+-      )
+-    )
+-  )
+-
+-  (elem declare func $$even $$odd)
+-  (global $$even (ref $$ll) (ref.func $$even))
+-  (global $$odd (ref $$ll) (ref.func $$odd))
+-
+-  (func $$even (export "even") (type $$ll)
+-    (if (result i64) (i64.eqz (local.get 0))
+-      (then (i64.const 44))
+-      (else (call_ref $$ll (i64.sub (local.get 0) (i64.const 1)) (global.get $$odd)))
+-    )
+-  )
+-  (func $$odd (export "odd") (type $$ll)
+-    (if (result i64) (i64.eqz (local.get 0))
+-      (then (i64.const 99))
+-      (else (call_ref $$ll (i64.sub (local.get 0) (i64.const 1)) (global.get $$even)))
+-    )
+-  )
+ )`);
+ 
+ // ./test/core/call_ref.wast:94
+@@ -118,69 +50,6 @@ assert_return(() => invoke($0, `run`, [3
+ // ./test/core/call_ref.wast:97
+ assert_trap(() => invoke($0, `null`, []), `null function`);
+
+-// ./test/core/call_ref.wast:99
+-assert_return(() => invoke($0, `fac`, [0n]), [value("i64", 1n)]);
+-
+-// ./test/core/call_ref.wast:100
+-assert_return(() => invoke($0, `fac`, [1n]), [value("i64", 1n)]);
+-
+-// ./test/core/call_ref.wast:101
+-assert_return(() => invoke($0, `fac`, [5n]), [value("i64", 120n)]);
+-
+-// ./test/core/call_ref.wast:102
+-assert_return(() => invoke($0, `fac`, [25n]), [value("i64", 7034535277573963776n)]);
+-
+-// ./test/core/call_ref.wast:103
+-assert_return(() => invoke($0, `fac-acc`, [0n, 1n]), [value("i64", 1n)]);
+-
+-// ./test/core/call_ref.wast:104
+-assert_return(() => invoke($0, `fac-acc`, [1n, 1n]), [value("i64", 1n)]);
+-
+-// ./test/core/call_ref.wast:105
+-assert_return(() => invoke($0, `fac-acc`, [5n, 1n]), [value("i64", 120n)]);
+-
+-// ./test/core/call_ref.wast:106
+-assert_return(() => invoke($0, `fac-acc`, [25n, 1n]), [value("i64", 7034535277573963776n)]);
+-
+-// ./test/core/call_ref.wast:111
+-assert_return(() => invoke($0, `fib`, [0n]), [value("i64", 1n)]);
+-
+-// ./test/core/call_ref.wast:112
+-assert_return(() => invoke($0, `fib`, [1n]), [value("i64", 1n)]);
+-
+-// ./test/core/call_ref.wast:113
+-assert_return(() => invoke($0, `fib`, [2n]), [value("i64", 2n)]);
+-
+-// ./test/core/call_ref.wast:114
+-assert_return(() => invoke($0, `fib`, [5n]), [value("i64", 8n)]);
+-
+-// ./test/core/call_ref.wast:115
+-assert_return(() => invoke($0, `fib`, [20n]), [value("i64", 10946n)]);
+-
+-// ./test/core/call_ref.wast:117
+-assert_return(() => invoke($0, `even`, [0n]), [value("i64", 44n)]);
+-
+-// ./test/core/call_ref.wast:118
+-assert_return(() => invoke($0, `even`, [1n]), [value("i64", 99n)]);
+-
+-// ./test/core/call_ref.wast:119
+-assert_return(() => invoke($0, `even`, [100n]), [value("i64", 44n)]);
+-
+-// ./test/core/call_ref.wast:120
+-assert_return(() => invoke($0, `even`, [77n]), [value("i64", 99n)]);
+-
+-// ./test/core/call_ref.wast:121
+-assert_return(() => invoke($0, `odd`, [0n]), [value("i64", 99n)]);
+-
+-// ./test/core/call_ref.wast:122
+-assert_return(() => invoke($0, `odd`, [1n]), [value("i64", 44n)]);
+-
+-// ./test/core/call_ref.wast:123
+-assert_return(() => invoke($0, `odd`, [200n]), [value("i64", 99n)]);
+-
+-// ./test/core/call_ref.wast:124
+-assert_return(() => invoke($0, `odd`, [77n]), [value("i64", 44n)]);
+-
+ // ./test/core/call_ref.wast:129
+ let $1 = instantiate(`(module
+   (type $$t (func))
+diff --git a/js/src/jit-test/tests/wasm/spec/function-references/local_get.wast.js b/js/src/jit-test/tests/wasm/spec/function-references/local_get.wast.js
+TODO Error: globals are of different type
+--- a/js/src/jit-test/tests/wasm/spec/function-references/local_get.wast.js
++++ b/js/src/jit-test/tests/wasm/spec/function-references/local_get.wast.js
+@@ -297,18 +297,6 @@ let $1 = instantiate(`(module
+   )
+ )`);
+
+-// ./test/core/local_get.wast:248
+-assert_return(() => invoke($1, `get-after-set`, [externref(1)]), [value('externref', externref(1))]);
+-
+-// ./test/core/local_get.wast:249
+-assert_return(() => invoke($1, `get-after-tee`, [externref(2)]), [value('externref', externref(2))]);
+-
+-// ./test/core/local_get.wast:250
+-assert_return(
+-  () => invoke($1, `get-in-block-after-set`, [externref(3)]),
+-  [value('externref', externref(3))],
+-);
+-
+ // ./test/core/local_get.wast:252
+ assert_invalid(
+   () => instantiate(`(module (func $$uninit (local $$x (ref extern)) (drop (local.get $$x))))`),
+diff --git a/js/src/jit-test/tests/wasm/spec/relaxed-simd/i32x4_relaxed_trunc.wast.js b/js/src/jit-test/tests/wasm/spec/relaxed-simd/i32x4_relaxed_trunc.wast.js
+--- a/js/src/jit-test/tests/wasm/spec/relaxed-simd/i32x4_relaxed_trunc.wast.js
++++ b/js/src/jit-test/tests/wasm/spec/relaxed-simd/i32x4_relaxed_trunc.wast.js
+@@ -92,6 +92,7 @@ assert_return(
+     either(
+       i32x4([0x0, 0x0, 0xffffff00, 0xffffffff]),
+       i32x4([0x0, 0xffffffff, 0xffffff00, 0xffffffff]),
++      i32x4([0x0, 0xffffffff, 0xffffff00, 0x0]),
+     ),
+   ],
+ );
+@@ -122,6 +123,7 @@ assert_return(
+     either(
+       i32x4([0x0, 0x0, 0x0, 0x0]),
+       i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
++      i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+     ),
+   ],
+ );
+@@ -173,6 +175,7 @@ assert_return(
+     either(
+       i32x4([0x0, 0xffffffff, 0x0, 0x0]),
+       i32x4([0xffffffff, 0xffffffff, 0x0, 0x0]),
++      i32x4([0xfffffffe, 0x0, 0x0, 0x0]),
+     ),
+   ],
+ );
diff --git a/js/src/jit-test/jit_test.py b/js/src/jit-test/jit_test.py
new file mode 100755
index 0000000000..d9f08a7e15
--- /dev/null
+++ b/js/src/jit-test/jit_test.py
@@ -0,0 +1,576 @@
+#!/usr/bin/env python
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+import math
+import os
+import platform
+import posixpath
+import shlex
+import subprocess
+import sys
+import traceback
+
+read_input = input
+if sys.version_info.major == 2:
+    read_input = raw_input
+
+
+def add_tests_dir_to_path():
+    from os.path import dirname, exists, join, realpath
+
+    js_src_dir = dirname(dirname(realpath(sys.argv[0])))
+    assert exists(join(js_src_dir, "jsapi.h"))
+    sys.path.insert(0, join(js_src_dir, "tests"))
+
+
+add_tests_dir_to_path()
+
+from lib import jittests
+from lib.tempfile import TemporaryDirectory
+from lib.tests import (
+    change_env,
+    get_cpu_count,
+    get_environment_overlay,
+    get_jitflags,
+    valid_jitflags,
+)
+
+
+def which(name):
+    if name.find(os.path.sep) != -1:
+        return os.path.abspath(name)
+
+    for path in os.environ["PATH"].split(os.pathsep):
+        full = os.path.join(path, name)
+        if os.path.exists(full):
+            return os.path.abspath(full)
+
+    return name
+
+
+def choose_item(jobs, max_items, display):
+    job_count = len(jobs)
+
+    # Don't present a choice if there are too many tests
+    if job_count > max_items:
+        raise Exception("Too many jobs.")
+
+    for i, job in enumerate(jobs, 1):
+        print("{}) {}".format(i, display(job)))
+
+    item = read_input("Which one:\n")
+    try:
+        item = int(item)
+        if item > job_count or item < 1:
+            raise Exception("Input isn't between 1 and {}".format(job_count))
+    except ValueError:
+        raise Exception("Unrecognized input")
+
+    return jobs[item - 1]
+
+
+def main(argv):
+    # The [TESTS] optional arguments are paths of test files relative
+    # to the jit-test/tests directory.
+    import argparse
+
+    op = argparse.ArgumentParser(description="Run jit-test JS shell tests")
+    op.add_argument(
+        "-s",
+        "--show-cmd",
+        dest="show_cmd",
+        action="store_true",
+        help="show js shell command run",
+    )
+    op.add_argument(
+        "-f",
+        "--show-failed-cmd",
+        dest="show_failed",
+        action="store_true",
+        help="show command lines of failed tests",
+    )
+    op.add_argument(
+        "-o",
+        "--show-output",
+        dest="show_output",
+        action="store_true",
+        help="show output from js shell",
+    )
+    op.add_argument(
+        "-F",
+        "--failed-only",
+        dest="failed_only",
+        action="store_true",
+        help="if --show-output is given, only print output for" " failed tests",
+    )
+    op.add_argument(
+        "--no-show-failed",
+        dest="no_show_failed",
+        action="store_true",
+        help="don't print output for failed tests" " (no-op with --show-output)",
+    )
+    op.add_argument(
+        "-x",
+        "--exclude",
+        dest="exclude",
+        default=[],
+        action="append",
+        help="exclude given test dir or path",
+    )
+    op.add_argument(
+        "--exclude-from",
+        dest="exclude_from",
+        type=str,
+        help="exclude each test dir or path in FILE",
+    )
+    op.add_argument(
+        "--slow",
+        dest="run_slow",
+        action="store_true",
+        help="also run tests marked as slow",
+    )
+    op.add_argument(
+        "--no-slow",
+        dest="run_slow",
+        action="store_false",
+        help="do not run tests marked as slow (the default)",
+    )
+    op.add_argument(
+        "-t",
+        "--timeout",
+        dest="timeout",
+        type=float,
+        default=150.0,
+        help="set test timeout in seconds",
+    )
+    op.add_argument(
+        "--no-progress",
+        dest="hide_progress",
+        action="store_true",
+        help="hide progress bar",
+    )
+    op.add_argument(
+        "--tinderbox",
+        dest="format",
+        action="store_const",
+        const="automation",
+        help="Use automation-parseable output format",
+    )
+    op.add_argument(
+        "--format",
+        dest="format",
+        default="none",
+        choices=("automation", "none"),
+        help="Output format (default %(default)s).",
+    )
+    op.add_argument(
+        "--args",
+        dest="shell_args",
+        metavar="ARGS",
+        default="",
+        help="extra args to pass to the JS shell",
+    )
+    op.add_argument(
+        "--feature-args",
+        dest="feature_args",
+        metavar="ARGS",
+        default="",
+        help="even more args to pass to the JS shell "
+        "(for compatibility with jstests.py)",
+    )
+    op.add_argument(
+        "-w",
+        "--write-failures",
+        dest="write_failures",
+        metavar="FILE",
+        help="Write a list of failed tests to [FILE]",
+    )
+    op.add_argument(
+        "-C",
+        "--check-output",
+        action="store_true",
+        dest="check_output",
+        help="Run tests to check output for different jit-flags",
+    )
+    op.add_argument(
+        "-r",
+        "--read-tests",
+        dest="read_tests",
+        metavar="FILE",
+        help="Run test files listed in [FILE]",
+    )
+    op.add_argument(
+        "-R",
+        "--retest",
+        dest="retest",
+        metavar="FILE",
+        help="Retest using test list file [FILE]",
+    )
+    op.add_argument(
+        "-g",
+        "--debug",
+        action="store_const",
+        const="gdb",
+        dest="debugger",
+        help="Run a single test under the gdb debugger",
+    )
+    op.add_argument(
+        "-G",
+        "--debug-rr",
+        action="store_const",
+        const="rr",
+        dest="debugger",
+        help="Run a single test under the rr debugger",
+    )
+    op.add_argument(
+        "--debugger", type=str, help="Run a single test under the specified debugger"
+    )
+    op.add_argument(
+        "--valgrind",
+        dest="valgrind",
+        action="store_true",
+        help="Enable the |valgrind| flag, if valgrind is in $PATH.",
+    )
+    op.add_argument(
+        "--unusable-error-status",
+        action="store_true",
+        help="Ignore incorrect exit status on tests that should return nonzero.",
+    )
+    op.add_argument(
+        "--valgrind-all",
+        dest="valgrind_all",
+        action="store_true",
+        help="Run all tests with valgrind, if valgrind is in $PATH.",
+    )
+    op.add_argument(
+        "--write-failure-output",
+        dest="write_failure_output",
+        action="store_true",
+        help="With --write-failures=FILE, additionally write the"
+        " output of failed tests to [FILE]",
+    )
+    op.add_argument(
+        "--jitflags",
+        dest="jitflags",
+        default="none",
+        choices=valid_jitflags(),
+        help="IonMonkey option combinations (default %(default)s).",
+    )
+    op.add_argument(
+        "--ion",
+        dest="jitflags",
+        action="store_const",
+        const="ion",
+        help="Run tests once with --ion-eager and once with"
+        " --baseline-eager (equivalent to --jitflags=ion)",
+    )
+    op.add_argument(
+        "--no-xdr",
+        dest="use_xdr",
+        action="store_false",
+        help="Whether to disable caching of self-hosted parsed content in XDR format.",
+    )
+    op.add_argument(
+        "--tbpl",
+        dest="jitflags",
+        action="store_const",
+        const="all",
+        help="Run tests with all IonMonkey option combinations"
+        " (equivalent to --jitflags=all)",
+    )
+    op.add_argument(
+        "-j",
+        "--worker-count",
+        dest="max_jobs",
+        type=int,
+        default=max(1, get_cpu_count()),
+        help="Number of tests to run in parallel (default %(default)s).",
+    )
+    op.add_argument(
+        "--remote", action="store_true", help="Run tests on a remote device"
+    )
+    op.add_argument(
+        "--deviceIP",
+        action="store",
+        type=str,
+        dest="device_ip",
+        help="IP address of remote device to test",
+    )
+    op.add_argument(
+        "--devicePort",
+        action="store",
+        type=int,
+        dest="device_port",
+        default=20701,
+        help="port of remote device to test",
+    )
+    op.add_argument(
+        "--deviceSerial",
+        action="store",
+        type=str,
+        dest="device_serial",
+        default=None,
+        help="ADB device serial number of remote device to test",
+    )
+    op.add_argument(
+        "--remoteTestRoot",
+        dest="remote_test_root",
+        action="store",
+        type=str,
+        default="/data/local/tmp/test_root",
+        help="The remote directory to use as test root" " (e.g.  %(default)s)",
+    )
+    op.add_argument(
+        "--localLib",
+        dest="local_lib",
+        action="store",
+        type=str,
+        help="The location of libraries to push -- preferably" " stripped",
+    )
+    op.add_argument(
+        "--repeat", type=int, default=1, help="Repeat tests the given number of times."
+    )
+    op.add_argument("--this-chunk", type=int, default=1, help="The test chunk to run.")
+    op.add_argument(
+        "--total-chunks", type=int, default=1, help="The total number of test chunks."
+    )
+    op.add_argument(
+        "--ignore-timeouts",
+        dest="ignore_timeouts",
+        metavar="FILE",
+        help="Ignore timeouts of tests listed in [FILE]",
+    )
+    op.add_argument(
+        "--retry-remote-timeouts",
+        dest="timeout_retry",
+        type=int,
+        default=1,
+        help="Number of time to retry timeout on remote devices",
+    )
+    op.add_argument(
+        "--test-reflect-stringify",
+        dest="test_reflect_stringify",
+        help="instead of running tests, use them to test the "
+        "Reflect.stringify code in specified file",
+    )
+    # --enable-webrender is ignored as it is not relevant for JIT
+    # tests, but is required for harness compatibility.
+    op.add_argument(
+        "--enable-webrender",
+        action="store_true",
+        dest="enable_webrender",
+        default=False,
+        help=argparse.SUPPRESS,
+    )
+    op.add_argument("js_shell", metavar="JS_SHELL", help="JS shell to run tests with")
+    op.add_argument(
+        "-z", "--gc-zeal", help="GC zeal mode to use when running the shell"
+    )
+
+    options, test_args = op.parse_known_args(argv)
+    js_shell = which(options.js_shell)
+    test_environment = get_environment_overlay(js_shell, options.gc_zeal)
+
+    if not (os.path.isfile(js_shell) and os.access(js_shell, os.X_OK)):
+        if (
+            platform.system() != "Windows"
+            or os.path.isfile(js_shell)
+            or not os.path.isfile(js_shell + ".exe")
+            or not os.access(js_shell + ".exe", os.X_OK)
+        ):
+            op.error("shell is not executable: " + js_shell)
+
+    if options.retest:
+        options.read_tests = options.retest
+        options.write_failures = options.retest
+
+    test_list = []
+    read_all = True
+
+    if test_args:
+        read_all = False
+        for arg in test_args:
+            test_list += jittests.find_tests(arg)
+
+    if options.read_tests:
+        read_all = False
+        try:
+            f = open(options.read_tests)
+            for line in f:
+                test_list.append(os.path.join(jittests.TEST_DIR, line.strip("\n")))
+            f.close()
+        except IOError:
+            if options.retest:
+                read_all = True
+            else:
+                sys.stderr.write(
+                    "Exception thrown trying to read test file"
+                    " '{}'\n".format(options.read_tests)
+                )
+                traceback.print_exc()
+                sys.stderr.write("---\n")
+
+    if read_all:
+        test_list = jittests.find_tests()
+
+    if options.exclude_from:
+        with open(options.exclude_from) as fh:
+            for line in fh:
+                line_exclude = line.strip()
+                if not line_exclude.startswith("#") and len(line_exclude):
+                    options.exclude.append(line_exclude)
+
+    if options.exclude:
+        exclude_list = []
+        for exclude in options.exclude:
+            exclude_list += jittests.find_tests(exclude)
+        test_list = [test for test in test_list if test not in set(exclude_list)]
+
+    if not test_list:
+        print("No tests found matching command line arguments.", file=sys.stderr)
+        sys.exit(0)
+
+    test_list = [jittests.JitTest.from_file(_, options) for _ in test_list]
+
+    if not options.run_slow:
+        test_list = [_ for _ in test_list if not _.slow]
+
+    if options.test_reflect_stringify is not None:
+        for test in test_list:
+            test.test_reflect_stringify = options.test_reflect_stringify
+
+    # If chunking is enabled, determine which tests are part of this chunk.
+    # This code was adapted from testing/mochitest/runtestsremote.py.
+    if options.total_chunks > 1:
+        total_tests = len(test_list)
+        tests_per_chunk = math.ceil(total_tests / float(options.total_chunks))
+        start = int(round((options.this_chunk - 1) * tests_per_chunk))
+        end = int(round(options.this_chunk * tests_per_chunk))
+        test_list = test_list[start:end]
+
+    if not test_list:
+        print(
+            "No tests found matching command line arguments after filtering.",
+            file=sys.stderr,
+        )
+        sys.exit(0)
+
+    # The full test list is ready. Now create copies for each JIT configuration.
+    test_flags = get_jitflags(options.jitflags)
+
+    test_list = [_ for test in test_list for _ in test.copy_variants(test_flags)]
+
+    job_list = (test for test in test_list)
+    job_count = len(test_list)
+
+    if options.repeat:
+
+        def repeat_copy(job_list_generator, repeat):
+            job_list = list(job_list_generator)
+            for i in range(repeat):
+                for test in job_list:
+                    if i == 0:
+                        yield test
+                    else:
+                        yield test.copy()
+
+        job_list = repeat_copy(job_list, options.repeat)
+        job_count *= options.repeat
+
+    if options.ignore_timeouts:
+        read_all = False
+        try:
+            with open(options.ignore_timeouts) as f:
+                ignore = set()
+                for line in f.readlines():
+                    path = line.strip("\n")
+                    ignore.add(path)
+                options.ignore_timeouts = ignore
+        except IOError:
+            sys.exit("Error reading file: " + options.ignore_timeouts)
+    else:
+        options.ignore_timeouts = set()
+
+    prefix = (
+        [js_shell] + shlex.split(options.shell_args) + shlex.split(options.feature_args)
+    )
+    prologue = os.path.join(jittests.LIB_DIR, "prologue.js")
+    if options.remote:
+        prologue = posixpath.join(options.remote_test_root, "lib", "prologue.js")
+
+    prefix += ["-p", prologue]
+
+    if options.debugger:
+        if job_count > 1:
+            print(
+                "Multiple tests match command line"
+                " arguments, debugger can only run one"
+            )
+            jobs = list(job_list)
+
+            def display_job(job):
+                flags = ""
+                if len(job.jitflags) != 0:
+                    flags = "({})".format(" ".join(job.jitflags))
+                return "{} {}".format(job.path, flags)
+
+            try:
+                tc = choose_item(jobs, max_items=50, display=display_job)
+            except Exception as e:
+                sys.exit(str(e))
+        else:
+            tc = next(job_list)
+
+        if options.debugger == "gdb":
+            debug_cmd = ["gdb", "--args"]
+        elif options.debugger == "lldb":
+            debug_cmd = ["lldb", "--"]
+        elif options.debugger == "rr":
+            debug_cmd = ["rr", "record"]
+        else:
+            debug_cmd = options.debugger.split()
+
+        with change_env(test_environment):
+            with TemporaryDirectory() as tempdir:
+                if options.debugger == "rr":
+                    subprocess.call(
+                        debug_cmd
+                        + tc.command(
+                            prefix, jittests.LIB_DIR, jittests.MODULE_DIR, tempdir
+                        )
+                    )
+                    os.execvp("rr", ["rr", "replay"])
+                else:
+                    os.execvp(
+                        debug_cmd[0],
+                        debug_cmd
+                        + tc.command(
+                            prefix, jittests.LIB_DIR, jittests.MODULE_DIR, tempdir
+                        ),
+                    )
+        sys.exit()
+
+    try:
+        ok = None
+        if options.remote:
+            ok = jittests.run_tests(job_list, job_count, prefix, options, remote=True)
+        else:
+            with change_env(test_environment):
+                ok = jittests.run_tests(job_list, job_count, prefix, options)
+        if not ok:
+            sys.exit(2)
+    except OSError:
+        if not os.path.exists(prefix[0]):
+            print(
+                "JS shell argument: file does not exist:" " '{}'".format(prefix[0]),
+                file=sys.stderr,
+            )
+            sys.exit(1)
+        else:
+            raise
+
+
+if __name__ == "__main__":
+    main(sys.argv[1:])
diff --git a/js/src/jit-test/lib/adhoc-multiplatform-test.js b/js/src/jit-test/lib/adhoc-multiplatform-test.js
new file mode 100644
index 0000000000..511edd47a7
--- /dev/null
+++ b/js/src/jit-test/lib/adhoc-multiplatform-test.js
@@ -0,0 +1,259 @@
+
+// This file provides a version of the functions
+//
+//   codegenTestX64_adhoc   (src/jit-test/lib/codegen-x64-test.js)
+//   codegenTestX86_adhoc   (src/jit-test/lib/codegen-x86-test.js)
+//   codegenTestARM64_adhoc (src/jit-test/lib/codegen-arm64-test.js)
+//   (and the equivalent arm(32) function)
+//
+// generalised so the output can be specified for all 4 targets in one place.
+//
+// Usage:
+//   codegenTestMultiplatform_adhoc(module_text, export_name,
+//                                  expectedAllTargets, options = {})
+//
+// where
+//   `expectedAllTargets` states the expected-output regexps for each target,
+//   thusly:
+//
+//   {x64: 'text', x86: 'text', arm64: 'text', arm: 'text'}
+//
+//   The arm(32) expected output is optional.  The other 3 must be present.
+//
+//   Each 'text' is a string that represents a regular expression, possibly
+//   with newlines, representing the instruction or instructions we are looking
+//   for for the operator.  Spaces in the expected-pattern are arbitrary, we
+//   preprocess the pattern to replace any space string with \s+.  Lines are
+//   separated by newlines and leading and trailing spaces are stripped.
+//   Pattern strings may be empty, denoting "no instruction(s)".
+//
+//  options specifies options thusly:
+//
+//    instanceBox: if present, an object with a `value` property that will
+//                 receive the constructed instance
+//
+//    log: for debugging -- print the disassembly and other info helpful to
+//         resolving test failures.  This is also printed on a test failure
+//         regardless of the log setting.
+//
+//    features: this is passed on verbatim to wasmEvalText,
+//              as its third argument.
+//
+//    no_prefix: by default, the required pattern must be immediately preceded
+//               by `<target>_prefix`, and this is checked.  Setting this to
+//               true skips the check.  Try not to use this.
+//
+//    no_suffix: by default, the required pattern must be immediately followed
+//               by `<target>_suffix`, and this is checked.  Setting this to
+//               true skips the check.  Try not to use this.
+//
+//    no_prefix/no_suffix apply to all 4 targets.  Per-target overrides are
+//    supported, by putting them in a suitably tagged sub-object, eg:
+//    options = {x86: {no_prefix: true}}
+
+load(libdir + "codegen-test-common.js");
+
+// Architectures supported by this script.
+const knownArchs = ["x64", "x86", "arm64", "arm"];
+
+// Architectures for which `expectedAllTargets` must supply an expected result.
+const requiredArchs = ["x64", "x86", "arm64"];
+
+// These define the end-of-prologue ("prefix") and start-of-epilogue
+// ("suffix") to be matched.
+const prefixAndSuffix =
+      {x64: {
+           prefix: `48 89 e5        mov %rsp, %rbp`,
+           suffix: `5d              pop %rbp`
+       },
+       x86: {
+           // The mov to e[ac]x is debug code, inserted by the register
+           // allocator to clobber e[ac]x before a move group.  But it is only
+           // present if there is a move group there.
+           prefix: `8b ec           mov %esp, %ebp(
+                    b. ef be ad de  mov \\$0xDEADBEEF, %e.x)?`,
+           // `.bp` because zydis chooses `rbp` even on 32-bit systems.
+           suffix: `5d              pop %.bp`
+       },
+       arm64: {
+           prefix: `910003fd        mov x29, sp
+                    910003fc        mov x28, sp`,
+           suffix: `f94003fd        ldr x29, \\[sp\\]`
+       },
+       arm: {
+           prefix: `e52db004        str fp, \\[sp, #-4\\]!
+                    e1a0b00d        mov fp, sp`,
+           suffix: `e49db004        ldr fp, \\[sp\\], #\\+4`
+       }
+      };
+
+// The options object may a mix of generic (all-targets) options and contain
+// sub-objects containing arch-specific options, for example:
+//
+//   {a_generic_option: 1337, x86: {no_prefix:true}, arm64: {foo:4771}}
+//
+// promoteArchSpecificOptions lifts options for `archName` to the top level
+// and deletes *all* arch-specific subobjects, hence producing the final
+// to-be-used option set.  For the above example, if `archName` is "x86" we
+// get:
+//
+//   {a_generic_option: 1337, no_prefix: true}
+//
+function promoteArchSpecificOptions(options, archName) {
+    assertEq(true, knownArchs.some(a => archName == a));
+    if (options.hasOwnProperty(archName)) {
+        let archOptions = options[archName];
+        for (optName in archOptions) {
+            options[optName] = archOptions[optName];
+            if (options.log) {
+                print("---- adding " + archName + "-specific option {"
+                      + optName + ":" + archOptions[optName] + "}");
+            }
+        }
+    }
+    for (a of knownArchs) {
+        delete options[a];
+    }
+    if (options.log) {
+        print("---- final options");
+        for (optName in options) {
+            print("{" + optName + ":" + options[optName] + "}");
+        }
+    }
+    return options;
+}
+
+// Main test function.  See comments at top of this file.
+function codegenTestMultiplatform_adhoc(module_text, export_name,
+                                        expectedAllTargets, options = {}) {
+    assertEq(hasDisassembler(), true);
+
+    // Check that we've been provided with an expected result for at least
+    // x64, x86 and arm64.
+    assertEq(true,
+             requiredArchs.every(a => expectedAllTargets.hasOwnProperty(a)));
+
+    // Poke the build-configuration object to find out what target we're
+    // generating code for.
+    let conf     = getBuildConfiguration();
+    let genX64   = conf.x64;
+    let genX86   = conf.x86;
+    let genArm64 = conf.arm64;
+    let genArm   = conf.arm;
+    // So far so good, except .. X64 or X86 might be emulating something else.
+    if (genX64 && genArm64 && conf['arm64-simulator']) {
+        genX64 = false;
+    }
+    if (genX86 && genArm && conf['arm-simulator']) {
+        genX86 = false;
+    }
+
+    // Check we've definitively identified exactly one architecture to test.
+    assertEq(1, [genX64, genX86, genArm64, genArm].map(x => x ? 1 : 0)
+                                                  .reduce((a,b) => a+b, 0));
+
+    // Decide on the arch name for which we're testing.  Everything is keyed
+    // off this.
+    let archName = "";
+    if (genX64) {
+        archName = "x64";
+    } else if (genX86) {
+        archName = "x86";
+    } else if (genArm64) {
+        archName = "arm64";
+    } else if (genArm) {
+        archName = "arm";
+    }
+    if (options.log) {
+        print("---- testing for architecture \"" + archName + "\"");
+    }
+    // If this fails, it means we're running on an "unknown" architecture.
+    assertEq(true, archName.length > 0);
+
+    // Finalise options, by promoting arch-specific ones to the top level of
+    // the options object.
+    options = promoteArchSpecificOptions(options, archName);
+
+    // Get the prefix and suffix strings for the target.
+    assertEq(true, prefixAndSuffix.hasOwnProperty(archName));
+    let prefix = prefixAndSuffix[archName].prefix;
+    let suffix = prefixAndSuffix[archName].suffix;
+    assertEq(true, prefix.length >= 10);
+    assertEq(true, suffix.length >= 10);
+
+    // Get the expected output string, or skip the test if no expected output
+    // has been provided.  Note, because of the assertion near the top of this
+    // file, this will currently only allow arm(32) tests to be skipped.
+    let expected = "";
+    if (expectedAllTargets.hasOwnProperty(archName)) {
+        expected = expectedAllTargets[archName];
+    } else {
+        // Paranoia.  Don't want to silently skip tests due to logic bugs above.
+        assertEq(archName, "arm");
+        if (options.log) {
+            print("---- !! no expected output for target, skipping !!");
+        }
+        return;
+    }
+
+    // Finalise the expected-result string, and stash the original for
+    // debug-printing.
+    expectedInitial = expected;
+    if (!options.no_prefix) {
+        expected = prefix + '\n' + expected;
+    }
+    if (!options.no_suffix) {
+        expected = expected + '\n' + suffix;
+    }
+    if (genArm) {
+        // For obscure reasons, the arm(32) disassembler prints the
+        // instruction word twice.  Rather than forcing all expected lines to
+        // do the same, we detect any line starting with 8 hex digits followed
+        // by a space, and duplicate them so as to match the
+        // disassembler's output.
+        let newExpected = "";
+        let pattern = /^[0-9a-fA-F]{8} /;
+        for (line of expected.split(/\n+/)) {
+            // Remove whitespace at the start of the line.  This could happen
+            // for continuation lines in backtick-style expected strings.
+            while (line.match(/^\s/)) {
+                line = line.slice(1);
+            }
+            if (line.match(pattern)) {
+                line = line.slice(0,9) + line;
+            }
+            newExpected = newExpected + line + "\n";
+        }
+        expected = newExpected;
+    }
+    expected = fixlines(expected);
+
+    // Compile the test case and collect disassembly output.
+    let ins = wasmEvalText(module_text, {}, options.features);
+    if (options.instanceBox)
+        options.instanceBox.value = ins;
+    let output = wasmDis(ins.exports[export_name], {tier:"ion", asString:true});
+
+    // Check for success, print diagnostics
+    let output_matches_expected = output.match(new RegExp(expected)) != null;
+    if (!output_matches_expected) {
+        print("---- adhoc-tier1-test.js: TEST FAILED ----");
+    }
+    if (options.log && output_matches_expected) {
+        print("---- adhoc-tier1-test.js: TEST PASSED ----");
+    }
+    if (options.log || !output_matches_expected) {
+        print("---- module text");
+        print(module_text);
+        print("---- actual");
+        print(output);
+        print("---- expected (initial)");
+        print(expectedInitial);
+        print("---- expected (as used)");
+        print(expected);
+        print("----");
+    }
+
+    // Finally, the whole point of this:
+    assertEq(output_matches_expected, true);
+}
diff --git a/js/src/jit-test/lib/andTestHelper.js b/js/src/jit-test/lib/andTestHelper.js
new file mode 100644
index 0000000000..8e89a399ae
--- /dev/null
+++ b/js/src/jit-test/lib/andTestHelper.js
@@ -0,0 +1,13 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+function andTestHelper(a, b, n)
+{
+  var k = 0;
+  for (var i = 0; i < n; i++) {
+    if (a && b)
+      k += i;
+  }
+  return k;
+}
diff --git a/js/src/jit-test/lib/array-compare.js b/js/src/jit-test/lib/array-compare.js
new file mode 100644
index 0000000000..ede737b8c3
--- /dev/null
+++ b/js/src/jit-test/lib/array-compare.js
@@ -0,0 +1,28 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+// Library file for tests to load.
+
+function SameValue(v1, v2)
+{
+  if (v1 === 0 && v2 === 0)
+    return 1 / v1 === 1 / v2;
+  if (v1 !== v1 && v2 !== v2)
+    return true;
+  return v1 === v2;
+}
+
+function arraysEqual(a1, a2)
+{
+  var len1 = a1.length, len2 = a2.length;
+  if (len1 !== len2)
+    return false;
+  for (var i = 0; i < len1; i++)
+  {
+    if (!SameValue(a1[i], a2[i]))
+      return false;
+  }
+  return true;
+}
+
diff --git a/js/src/jit-test/lib/asm.js b/js/src/jit-test/lib/asm.js
new file mode 100644
index 0000000000..5a9606a8f1
--- /dev/null
+++ b/js/src/jit-test/lib/asm.js
@@ -0,0 +1,126 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+load(libdir + "asserts.js");
+
+const USE_ASM = '"use asm";';
+const HEAP_IMPORTS = "const i8=new glob.Int8Array(b);var u8=new glob.Uint8Array(b);"+
+                     "const i16=new glob.Int16Array(b);var u16=new glob.Uint16Array(b);"+
+                     "const i32=new glob.Int32Array(b);var u32=new glob.Uint32Array(b);"+
+                     "const f32=new glob.Float32Array(b);var f64=new glob.Float64Array(b);";
+const BUF_MIN = 64 * 1024;
+const BUF_CHANGE_MIN = 16 * 1024 * 1024;
+const BUF_64KB = new ArrayBuffer(BUF_MIN);
+
+function asmCompile()
+{
+    var f = Function.apply(null, arguments);
+    assertEq(!isAsmJSCompilationAvailable() || isAsmJSModule(f), true);
+    return f;
+}
+
+function asmCompileCached()
+{
+    if (!isAsmJSCompilationAvailable())
+        return Function.apply(null, arguments);
+
+    var f = Function.apply(null, arguments);
+    assertEq(isAsmJSModule(f), true);
+    return f;
+}
+
+function assertAsmDirectiveFail(str)
+{
+    if (!isAsmJSCompilationAvailable())
+        return;
+
+    assertWarning(() => {
+        eval(str)
+    }, /meaningful in the Directive Prologue/);
+}
+
+function assertAsmTypeFail()
+{
+    if (!isAsmJSCompilationAvailable())
+        return;
+
+    // Verify no error is thrown with warnings off
+    Function.apply(null, arguments);
+
+    // Turn on throwing on validation errors
+    var oldOpts = options("throw_on_asmjs_validation_failure");
+    assertEq(oldOpts.indexOf("throw_on_asmjs_validation_failure"), -1);
+
+    var caught = false;
+    try {
+        Function.apply(null, arguments);
+    } catch (e) {
+        if (!e.message.includes("asm.js type error:"))
+            throw new Error("Didn't catch the expected type failure error; instead caught: " + e + "\nStack: " + new Error().stack);
+        caught = true;
+    }
+    if (!caught)
+        throw new Error("Didn't catch the type failure error");
+
+    // Turn warnings-as-errors back off
+    options("throw_on_asmjs_validation_failure");
+}
+
+function assertAsmLinkFail(f, ...args)
+{
+    if (!isAsmJSCompilationAvailable())
+        return;
+
+    assertEq(isAsmJSModule(f), true);
+
+    // Verify no error is thrown with warnings off
+    var ret = f.apply(null, args);
+
+    assertEq(isAsmJSFunction(ret), false);
+    if (typeof ret === 'object') {
+        for (var i in ret) {
+            assertEq(isAsmJSFunction(ret[i]), false);
+        }
+    }
+
+    assertWarning(() => {
+        f.apply(null, args);
+    }, /disabled by linker/);
+}
+
+// Linking should throw an exception even without warnings-as-errors
+function assertAsmLinkAlwaysFail(f, ...args)
+{
+    var caught = false;
+    try {
+        f.apply(null, args);
+    } catch (e) {
+        caught = true;
+    }
+    if (!caught)
+        throw new Error("Didn't catch the link failure error");
+}
+
+function assertAsmLinkDeprecated(f, ...args)
+{
+    if (!isAsmJSCompilationAvailable())
+        return;
+
+    assertWarning(() => {
+        f.apply(null, args);
+    }, /asm.js type error:/)
+}
+
+function asmLink(f, ...args)
+{
+    if (!isAsmJSCompilationAvailable())
+        return f.apply(null, args);
+
+    var ret;
+    assertNoWarning(() => {
+        ret = f.apply(null, args);
+    }, "No warning for asmLink")
+
+    return ret;
+}
diff --git a/js/src/jit-test/lib/assert-offset-columns.js b/js/src/jit-test/lib/assert-offset-columns.js
new file mode 100644
index 0000000000..6fb75ac74c
--- /dev/null
+++ b/js/src/jit-test/lib/assert-offset-columns.js
@@ -0,0 +1,79 @@
+// Set breakpoints "everywhere" in a function, then call the function and check that
+// the breakpoints were added are at the expected columns, and the breakpoints
+// were executed in th expected order.
+//
+// `code` is a JS Script. The final line should define a function `f` to validate.
+// `expectedBpts` is a string of spaces and carets ('^'). Throws if we don't hit
+// breakpoints on exactly the columns indicated by the carets.
+// `expectedOrdering` is a string of integer indices for the offsets that are
+// executed, in the order that then are executed. Test code can also push
+// additional items into this string using items.push("!").
+function assertOffsetColumns(code, expectedBpts, expectedOrdering = null) {
+    if (expectedOrdering === null) {
+        // The default ordering simply runs the breakpoints in order.
+        expectedOrdering = Array.from(expectedBpts.match(/\^/g), (_, i) => i).join(" ");
+    }
+
+    // Define the function `f` in a new global.
+    const global = newGlobal({newCompartment: true});
+
+    const lines = code.split(/\r?\n|\r]/g);
+    const initCode = lines.slice(0, -1).join("\n");
+    const execCode = lines[lines.length - 1];
+
+    // Treat everything but the last line as initialization code.
+    global.eval(initCode);
+
+    // Run the test code itself.
+    global.eval(execCode);
+
+    // Allow some tests to append to a log that will show up in expected ordering.
+    const hits = global.hits = [];
+    const bpts = new Set();
+
+    // Set breakpoints everywhere and call the function.
+    const dbg = new Debugger;
+    let debuggeeFn = dbg.addDebuggee(global).makeDebuggeeValue(global.f);
+    if (debuggeeFn.isBoundFunction) {
+        debuggeeFn = debuggeeFn.boundTargetFunction;
+    }
+
+    const { script } = debuggeeFn;
+    for (const offset of script.getAllColumnOffsets()) {
+        assertEq(offset.lineNumber, 1);
+        assertEq(offset.columnNumber < execCode.length, true);
+        bpts.add(offset.columnNumber);
+
+        script.setBreakpoint(offset.offset, {
+            hit(frame) {
+                hits.push(offset.columnNumber);
+            },
+        });
+    }
+    global.f(3);
+
+    const actualBpts = Array.from(execCode, (_, i) => {
+        return bpts.has(i) ? "^" : " ";
+    }).join("");
+
+    if (actualBpts.trimEnd() !== expectedBpts.trimEnd()) {
+        throw new Error(`Assertion failed:
+                     code: ${execCode}
+            expected bpts: ${expectedBpts}
+              actual bpts: ${actualBpts}\n`);
+    }
+
+    const indexLookup = new Map(
+        Array.from(bpts).sort().map((col, i) => [col, i]));
+    const actualOrdering = hits
+        .map(item => typeof item === "number" ? indexLookup.get(item) : item)
+        .join(" ");
+
+    if (actualOrdering.trimEnd() !== expectedOrdering.trimEnd()) {
+        throw new Error(`Assertion failed:
+                     code: ${execCode}
+                     bpts: ${expectedBpts}
+           expected order: ${expectedOrdering}
+             actual order: ${actualOrdering}\n`);
+    }
+}
diff --git a/js/src/jit-test/lib/asserts.js b/js/src/jit-test/lib/asserts.js
new file mode 100644
index 0000000000..f0b3fe3bff
--- /dev/null
+++ b/js/src/jit-test/lib/asserts.js
@@ -0,0 +1,87 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+
+load(libdir + "non262.js");
+
+if (typeof assertWarning === 'undefined') {
+    var assertWarning = function assertWarning(f, pattern) {
+        enableLastWarning();
+
+        // Verify that a warning is issued.
+        clearLastWarning();
+        f();
+        var warning = getLastWarning();
+        clearLastWarning();
+
+        disableLastWarning();
+
+        if (warning) {
+            if (!warning.message.match(pattern)) {
+                throw new Error(`assertWarning failed: "${warning.message}" does not match "${pattern}"`);
+            }
+            return;
+        }
+
+        throw new Error("assertWarning failed: no warning");
+    };
+}
+
+if (typeof assertNoWarning === 'undefined') {
+    var assertNoWarning = function assertNoWarning(f, msg) {
+        enableLastWarning();
+
+        // Verify that no warning is issued.
+        clearLastWarning();
+        f();
+        var warning = getLastWarning();
+        clearLastWarning();
+
+        disableLastWarning();
+
+        if (warning) {
+            if (msg) {
+                print("assertNoWarning: " + msg);
+            }
+
+            throw Error("assertNoWarning: Unexpected warning when calling: " + f);
+        }
+    };
+}
+
+if (typeof assertErrorMessage === 'undefined') {
+    var assertErrorMessage = function assertErrorMessage(f, ctor, test) {
+        try {
+            f();
+        } catch (e) {
+            // Propagate non-specific OOM errors, we never test for these with
+            // assertErrorMessage, as there is no meaningful ctor.
+            if (e === "out of memory")
+                throw e;
+            if (!(e instanceof ctor))
+                throw new Error("Assertion failed: expected exception " + ctor.name + ", got " + e);
+            if (typeof test == "string") {
+                if (test != e.message)
+                    throw new Error("Assertion failed: expected " + test + ", got " + e.message);
+            } else {
+                if (!test.test(e.message))
+                    throw new Error("Assertion failed: expected " + test.toString() + ", got " + e.message);
+            }
+            return;
+        }
+        throw new Error("Assertion failed: expected exception " + ctor.name + ", no exception thrown");
+    };
+}
+
+if (typeof assertTypeErrorMessage === 'undefined') {
+    var assertTypeErrorMessage = function assertTypeErrorMessage(f, test) {
+      assertErrorMessage(f, TypeError, test);
+    };
+}
+
+if (typeof assertRangeErrorMessage === 'undefined') {
+    var assertRangeErrorMessage = function assertRangeErrorMessage(f, test) {
+      assertErrorMessage(f, RangeError, test);
+    };
+}
diff --git a/js/src/jit-test/lib/bytecode-cache.js b/js/src/jit-test/lib/bytecode-cache.js
new file mode 100644
index 0000000000..1f8f58643a
--- /dev/null
+++ b/js/src/jit-test/lib/bytecode-cache.js
@@ -0,0 +1,55 @@
+
+function evalWithCache(code, ctx) {
+  ctx = ctx || {};
+  ctx = Object.create(ctx, {
+    fileName: { value: "evalWithCacheCode.js" },
+    lineNumber: { value: 0 }
+  });
+  code = code instanceof Object ? code : cacheEntry(code);
+
+  var incremental = ctx.incremental || false;
+
+  // We create a new global ...
+  if (!("global" in ctx))
+      ctx.global = newGlobal({newCompartment: ctx.newCompartment});
+
+  var ctx_save = Object.create(ctx, {
+    saveIncrementalBytecode: { value: true }
+  });
+
+  // Fetch the verification function from the evaluation context.  This function
+  // is used to assert the state of the script/function after each run of the
+  // evaluate function.
+  var checkAfter = ctx.checkAfter || function(ctx) {};
+
+  // The generation counter is used to represent environment variations which
+  // might cause the program to run differently, and thus to have a different
+  // set of functions executed.
+  ctx.global.generation = 0;
+  var res1 = evaluate(code, ctx_save);
+  checkAfter(ctx);
+
+  ctx.global.generation = 1;
+  var res2 = evaluate(code, Object.create(ctx_save, {loadBytecode: { value: true } }));
+  checkAfter(ctx);
+
+  ctx.global.generation = 2;
+  var res3 = evaluate(code, Object.create(ctx, {loadBytecode: { value: true } }));
+  checkAfter(ctx);
+
+  ctx.global.generation = 3;
+  var res0 = evaluate(code, ctx);
+  checkAfter(ctx);
+
+  if (ctx.assertEqResult) {
+    assertEq(res0, res1);
+    assertEq(res0, res2);
+    assertEq(res0, res3);
+  }
+
+  if (ctx.checkFrozen) {
+    assertEq(Object.isFrozen(res0), Object.isFrozen(res1));
+    assertEq(Object.isFrozen(res0), Object.isFrozen(res2));
+    assertEq(Object.isFrozen(res0), Object.isFrozen(res3));
+  }
+}
diff --git a/js/src/jit-test/lib/census.js b/js/src/jit-test/lib/census.js
new file mode 100644
index 0000000000..79de8d0060
--- /dev/null
+++ b/js/src/jit-test/lib/census.js
@@ -0,0 +1,161 @@
+// Functions for checking results returned by Debugger.Memory.prototype.takeCensus.
+
+const Census = {};
+
+(function () {
+
+  // Census.walkCensus(subject, name, walker[, ignore])
+  //
+  // Use |walker| to check |subject|, a census object of the sort returned by
+  // Debugger.Memory.prototype.takeCensus: a tree of objects with integers at the
+  // leaves. Use |name| as the name for |subject| in diagnostic messages. Return
+  // the number of leaves of |subject| we visited.
+  //
+  // A walker is an object with three methods:
+  //
+  // - enter(prop): Return the walker we should use to check the property of the
+  //   subject census named |prop|. This is for recursing into the subobjects of
+  //   the subject.
+  //
+  // - done(ignore): Called after we have called 'enter' on every property of
+  //   the subject. Passed the |ignore| set of properties.
+  //
+  // - check(value): Check |value|, a leaf in the subject.
+  //
+  // Walker methods are expected to simply throw if a node we visit doesn't look
+  // right.
+  //
+  // The optional |ignore| parameter allows you to specify a |Set| of property
+  // names which should be ignored. The walker will not traverse such
+  // properties.
+  Census.walkCensus = (subject, name, walker, ignore = new Set()) =>
+    walk(subject, name, walker, ignore, 0);
+
+  function walk(subject, name, walker, ignore, count) {
+    if (typeof subject === 'object') {
+      print(name);
+      for (let prop in subject) {
+        if (ignore.has(prop)) {
+          continue;
+        }
+        count = walk(subject[prop],
+                     name + "[" + JSON.stringify(prop) + "]",
+                     walker.enter(prop),
+                     ignore,
+                     count);
+      }
+      walker.done(ignore);
+    } else {
+      print(name + " = " + JSON.stringify(subject));
+      walker.check(subject);
+      count++;
+    }
+
+    return count;
+  }
+
+  // A walker that doesn't check anything.
+  Census.walkAnything = {
+    enter: () => Census.walkAnything,
+    done: () => undefined,
+    check: () => undefined
+  };
+
+  // A walker that requires all leaves to be zeros.
+  Census.assertAllZeros = {
+    enter: () => Census.assertAllZeros,
+    done: () => undefined,
+    check: elt => assertEq(elt, 0)
+  };
+
+  function expectedObject() {
+    throw "Census mismatch: subject has leaf where basis has nested object";
+  }
+
+  function expectedLeaf() {
+    throw "Census mismatch: subject has nested object where basis has leaf";
+  }
+
+  // Return a function that, given a 'basis' census, returns a census walker that
+  // compares the subject census against the basis. The returned walker calls the
+  // given |compare|, |missing|, and |extra| functions as follows:
+  //
+  // - compare(subjectLeaf, basisLeaf): Check a leaf of the subject against the
+  //   corresponding leaf of the basis.
+  //
+  // - missing(prop, value): Called when the subject is missing a property named
+  //   |prop| which is present in the basis with value |value|.
+  //
+  // - extra(prop): Called when the subject has a property named |prop|, but the
+  //   basis has no such property. This should return a walker that can check
+  //   the subject's value.
+  function makeBasisChecker({compare, missing, extra}) {
+    return function makeWalker(basis) {
+      if (typeof basis === 'object') {
+        var unvisited = new Set(Object.getOwnPropertyNames(basis));
+        return {
+          enter: prop => {
+            unvisited.delete(prop);
+            if (prop in basis) {
+              return makeWalker(basis[prop]);
+            } else {
+              return extra(prop);
+            }
+          },
+
+          done: ignore => [...unvisited].filter(p => !ignore.has(p)).forEach(p => missing(p, basis[p])),
+          check: expectedObject
+        };
+      } else {
+        return {
+          enter: expectedLeaf,
+          done: expectedLeaf,
+          check: elt => compare(elt, basis)
+        };
+      }
+    };
+  }
+
+  function missingProp(prop) {
+    throw "Census mismatch: subject lacks property present in basis: " + JSON.stringify(prop);
+  }
+
+  function extraProp(prop) {
+    throw "Census mismatch: subject has property not present in basis: " + JSON.stringify(prop);
+  }
+
+  // Return a walker that checks that the subject census has counts all equal to
+  // |basis|.
+  Census.assertAllEqual = makeBasisChecker({
+    compare: assertEq,
+    missing: missingProp,
+    extra: extraProp
+  });
+
+  // Return a walker that checks that the subject census has at least as many
+  // items of each category as |basis|.
+  Census.assertAllNotLessThan = makeBasisChecker({
+    compare: (subject, basis) => assertEq(subject >= basis, true),
+    missing: missingProp,
+    extra: () => Census.walkAnything
+  });
+
+  // Return a walker that checks that the subject census has at most as many
+  // items of each category as |basis|.
+  Census.assertAllNotMoreThan = makeBasisChecker({
+    compare: (subject, basis) => assertEq(subject <= basis, true),
+    missing: missingProp,
+    extra: () => Census.walkAnything
+  });
+
+  // Return a walker that checks that the subject census has within |fudge|
+  // items of each category of the count in |basis|.
+  Census.assertAllWithin = function (fudge, basis) {
+    return makeBasisChecker({
+      compare: (subject, basis) => assertEq(Math.abs(subject - basis) <= fudge, true),
+      missing: missingProp,
+      extra: () => Census.walkAnything
+    })(basis);
+  }
+
+})();
diff --git a/js/src/jit-test/lib/codegen-arm64-test.js b/js/src/jit-test/lib/codegen-arm64-test.js
new file mode 100644
index 0000000000..542f34f826
--- /dev/null
+++ b/js/src/jit-test/lib/codegen-arm64-test.js
@@ -0,0 +1,40 @@
+// Scaffolding for testing arm64 Ion code generation patterns .  See
+// codegen-x64-test.js in this directory for more information.
+
+load(libdir + "codegen-test-common.js");
+
+// End of prologue
+var arm64_prefix = `
+910003fd  mov     x29, sp
+910003fc  mov     x28, sp
+`;
+
+// Start of epilogue
+var arm64_suffix = `
+f94003fd  ldr     x29, \\[sp\\]
+`;
+
+// For when nothing else applies: `module_text` is the complete source text of
+// the module, `export_name` is the name of the function to be tested,
+// `expected` is the non-preprocessed pattern, and options is an options bag,
+// described above.
+function codegenTestARM64_adhoc(module_text, export_name, expected, options = {}) {
+    assertEq(hasDisassembler(), true);
+
+    let ins = wasmEvalText(module_text, {}, options.features);
+    if (options.instanceBox)
+        options.instanceBox.value = ins;
+    let output = wasmDis(ins.exports[export_name], {tier:"ion", asString:true});
+    if (!options.no_prefix)
+        expected = arm64_prefix + '\n' + expected;
+    if (!options.no_suffix)
+        expected = expected + '\n' + arm64_suffix;
+    expected = fixlines(expected);
+    if (options.log) {
+        print(module_text);
+        print(output);
+        print(expected);
+    }
+    assertEq(output.match(new RegExp(expected)) != null, true);
+}
+
diff --git a/js/src/jit-test/lib/codegen-test-common.js b/js/src/jit-test/lib/codegen-test-common.js
new file mode 100644
index 0000000000..ad5511746b
--- /dev/null
+++ b/js/src/jit-test/lib/codegen-test-common.js
@@ -0,0 +1,53 @@
+// Set to true to emit ' +' instead of the unreadable '\s+'.
+var SPACEDEBUG = false;
+
+// Any hex string
+var HEX = '[0-9a-fA-F]'
+var HEXES = `${HEX}+`;
+
+function wrap(options, funcs) {
+    if ('memory' in options)
+        return `(module (memory ${options.memory}) ${funcs})`;
+    return `(module ${funcs})`;
+}
+
+function fixlines(s) {
+    return s.split(/\n+/)
+        .map(strip)
+        .filter(x => x.length > 0)
+        .map(x => '(?:0x)?' + HEXES + ' ' + x)
+        .map(spaces)
+        .join('\n');
+}
+
+function strip(s) {
+    while (s.length > 0 && isspace(s.charAt(0)))
+        s = s.substring(1);
+    while (s.length > 0 && isspace(s.charAt(s.length-1)))
+        s = s.substring(0, s.length-1);
+    return s;
+}
+
+function striplines(s) {
+    return s.split('\n').map(strip).join('\n');
+}
+
+function spaces(s) {
+    let t = '';
+    let i = 0;
+    while (i < s.length) {
+        if (isspace(s.charAt(i))) {
+            t += SPACEDEBUG ? ' +' : '\\s+';
+            i++;
+            while (i < s.length && isspace(s.charAt(i)))
+                i++;
+        } else {
+            t += s.charAt(i++);
+        }
+    }
+    return t;
+}
+
+function isspace(c) {
+    return c == ' ' || c == '\t';
+}
diff --git a/js/src/jit-test/lib/codegen-x64-test.js b/js/src/jit-test/lib/codegen-x64-test.js
new file mode 100644
index 0000000000..5d64226bf2
--- /dev/null
+++ b/js/src/jit-test/lib/codegen-x64-test.js
@@ -0,0 +1,184 @@
+// Scaffolding for testing x64 Ion code generation patterns).  See
+// ../tests/wasm/README-codegen.md for general information, and the *codegen.js
+// tests in that directory and its subdirectories for specifics.
+//
+// The structure of the inputs can vary for the different testing predicates but
+// each case generally has an operator name and an expected-pattern; the latter
+// is a string that represents a regular expression, possibly with newlines,
+// representing the instruction or instructions we are looking for for the
+// operator.  Spaces in the expected-pattern are arbitrary, we preprocess the
+// pattern to replace any space string with \s+.  Lines are separated by
+// newlines and leading and trailing spaces are currently stripped.
+//
+// The testers additionally take an optional options bag with the following
+// optional entries:
+//  features: if present, an object to pass as the last argument to functions
+//            that compile wasm bytecode
+//  instanceBox: if present, an object with a `value` property that will
+//               receive the constructed instance
+//  no_prefix: by default, the required pattern must be immediately preceded
+//             by `x64_prefix`, and this is checked.  Setting this to true skips
+//             the check.
+//  no_suffix: by default, the required pattern must be immediately followed
+//             by `x64_suffix`, and this is checked.  Setting this to true skips
+//             the check.
+//  memory: if present, add a memory of length given by this property
+//  log: for debugging -- print the disassembly, then the preprocessed pattern
+
+load(libdir + "codegen-test-common.js");
+
+// RIP-relative address following the instruction mnemonic
+var RIPR = `0x${HEXES}`;
+
+// RIP-relative address in the binary encoding
+var RIPRADDR = `${HEX}{2} ${HEX}{2} ${HEX}{2} ${HEX}{2}`;
+
+// End of prologue
+var x64_prefix = `48 89 e5                  mov %rsp, %rbp`
+
+// Start of epilogue
+var x64_suffix = `5d                        pop %rbp`;
+
+// v128 OP v128 -> v128
+// inputs: [[complete-opname, expected-pattern], ...]
+function codegenTestX64_v128xv128_v128(inputs, options = {}) {
+    for ( let [op, expected] of inputs ) {
+        codegenTestX64BinopInternal(op, expected, options, 'v128', 'v128', 'v128', '0', '1');
+    }
+}
+
+// v128 OP param1-type -> v128
+// inputs: [[complete-opname, param1-type, expected-pattern], ...]
+function codegenTestX64_v128xPTYPE_v128(inputs, options = {}) {
+    for ( let [op, p1type, expected] of inputs ) {
+        codegenTestX64BinopInternal(op, expected, options, 'v128', p1type, 'v128', '0', '1');
+    }
+}
+
+// v128 OP literal -> v128
+// inputs: [[complete-opname, rhs-literal, expected-pattern], ...]
+function codegenTestX64_v128xLITERAL_v128(inputs, options = {}) {
+    for ( let [op, literal, expected] of inputs ) {
+        codegenTestX64_adhoc(wrap(options, `
+    (func (export "f") (param v128) (result v128)
+      (${op} (local.get 0) ${literal}))`),
+                              'f',
+                              expected,
+                              options)
+    }
+}
+
+// literal OP v128 -> v128
+// inputs: [[complete-opname, lhs-literal, expected-pattern], ...]
+function codegenTestX64_LITERALxv128_v128(inputs, options = {}) {
+    for ( let [op, literal, expected] of inputs ) {
+        codegenTestX64_adhoc(wrap(options, `
+    (func (export "f") (param v128) (result v128)
+      (${op} ${literal} (local.get 0)))`),
+                              'f',
+                              expected,
+                              options)
+    }
+}
+
+// v128 OP v128 -> v128, but operands are swapped
+// inputs: [[complete-opname, expected-pattern], ...]
+function codegenTestX64_v128xv128_v128_reversed(inputs, options = {}) {
+    for ( let [op, expected] of inputs ) {
+        codegenTestX64BinopInternal(op, expected, options, 'v128', 'v128', 'v128', '1', '0');
+    }
+}
+
+// OP v128 -> v128
+// inputs: [[complete-opname, expected-pattern], ...]
+function codegenTestX64_v128_v128(inputs, options = {}) {
+    for ( let [op, expected] of inputs ) {
+        codegenTestX64_adhoc(wrap(options, `
+    (func (export "f") (param v128) (result v128)
+      (${op} (local.get 0)))`),
+                             'f',
+                             expected,
+                             options);
+    }
+}
+
+// OP param-type -> v128
+// inputs [[complete-opname, param-type, expected-pattern], ...]
+function codegenTestX64_PTYPE_v128(inputs, options = {}) {
+    for ( let [op, ptype, expected] of inputs ) {
+        codegenTestX64_adhoc(wrap(options, `
+    (func (export "f") (param ${ptype}) (result v128)
+      (${op} (local.get 0)))`),
+                             'f',
+                             expected,
+                             options);
+    }
+}
+
+// OP v128 -> v128, but the function takes two arguments and the first is ignored
+// inputs: [[complete-opname, expected-pattern], ...]
+function codegenTestX64_IGNOREDxv128_v128(inputs, options = {}) {
+    for ( let [op, expected] of inputs ) {
+        codegenTestX64_adhoc(wrap(options, `
+    (func (export "f") (param v128) (param v128) (result v128)
+      (${op} (local.get 1)))`),
+                             'f',
+                             expected,
+                             options);
+    }
+}
+
+// () -> v128
+// inputs: [[complete-opname, expected-pattern], ...]
+function codegenTestX64_unit_v128(inputs, options = {}) {
+    for ( let [op, expected] of inputs ) {
+        codegenTestX64_adhoc(wrap(options, `
+   (func (export "f") (result v128)
+     (${op}))`),
+                             'f',
+                             expected,
+                             options);
+    }
+}
+
+// For when nothing else applies: `module_text` is the complete source text of
+// the module, `export_name` is the name of the function to be tested,
+// `expected` is the non-preprocessed pattern, and options is an options bag,
+// described above.
+function codegenTestX64_adhoc(module_text, export_name, expected, options = {}) {
+    assertEq(hasDisassembler(), true);
+
+    let ins = wasmEvalText(module_text, {}, options.features);
+    if (options.instanceBox)
+        options.instanceBox.value = ins;
+    let output = wasmDis(ins.exports[export_name], {tier:"ion", asString:true});
+    if (!options.no_prefix)
+        expected = x64_prefix + '\n' + expected;
+    if (!options.no_suffix)
+        expected = expected + '\n' + x64_suffix;
+    const expected_pretty = striplines(expected);
+    expected = fixlines(expected);
+
+    const success = output.match(new RegExp(expected)) != null;
+    if (options.log || !success) {
+        print("Module text:")
+        print(module_text);
+        print("Actual output:")
+        print(output);
+        print("Expected output (easy-to-read and fully-regex'd):")
+        print(expected_pretty);
+        print(expected);
+    }
+    assertEq(success, true);
+}
+
+// Internal code below this line
+
+function codegenTestX64BinopInternal(op, expected, options, p0type, p1type, restype, arg0, arg1) {
+    codegenTestX64_adhoc(wrap(options, `
+    (func (export "f") (param ${p0type}) (param ${p1type}) (result ${restype})
+      (${op} (local.get ${arg0}) (local.get ${arg1})))`),
+                         'f',
+                         expected,
+                         options);
+}
diff --git a/js/src/jit-test/lib/codegen-x86-test.js b/js/src/jit-test/lib/codegen-x86-test.js
new file mode 100644
index 0000000000..edf3e916fb
--- /dev/null
+++ b/js/src/jit-test/lib/codegen-x86-test.js
@@ -0,0 +1,84 @@
+// Scaffolding for testing x86 Ion code generation patterns .  See
+// codegen-x64-test.js in this directory for more information.
+
+load(libdir + "codegen-test-common.js");
+
+// Note that Zydis disassembles x86 absolute addresses as relative, so
+// the binary encoding and the text encoding may not correspond precisely.
+
+// Absolute address (disp32) following the instruction mnemonic.
+var ABS = `0x${HEXES}`;
+
+// Absolute address (disp32) in the binary encoding.
+var ABSADDR = `${HEX}{2} ${HEX}{2} ${HEX}{2} ${HEX}{2}`;
+
+// End of prologue.  The mov to eax is debug code, inserted by the register
+// allocator to clobber eax before a move group.  But it is only present if
+// there is a move group there.
+//
+// -0x21524111 is 0xDEADBEEF.
+var x86_prefix = `
+8b ec            mov %esp, %ebp(
+b8 ef be ad de   mov \\$-0x21524111, %eax)?
+`
+
+// `.bp` because zydis chooses 'rbp' even on 32-bit systems
+var x86_loadarg0 = `
+f3 0f 6f 45 ${HEX}{2}            movdqux 0x${HEXES}\\(%.bp\\), %xmm0
+`;
+
+// Start of epilogue.  `.bp` for the same reason as above.
+var x86_suffix = `5d      pop %.bp`;
+
+// v128 OP literal -> v128
+// inputs: [[complete-opname, rhs-literal, expected-pattern], ...]
+function codegenTestX86_v128xLITERAL_v128(inputs, options = {}) {
+    for ( let [op, literal, expected] of inputs ) {
+        codegenTestX86_adhoc(wrap(options, `
+    (func (export "f") (param v128) (result v128)
+      (${op} (local.get 0) ${literal}))`),
+                             'f',
+                             x86_loadarg0 + expected,
+                             options)
+    }
+}
+
+// For when nothing else applies: `module_text` is the complete source text of
+// the module, `export_name` is the name of the function to be tested,
+// `expected` is the non-preprocessed pattern, and options is an options bag,
+// described above.
+function codegenTestX86_adhoc(module_text, export_name, expected, options = {}) {
+    assertEq(hasDisassembler(), true);
+
+    let ins = wasmEvalText(module_text);
+    let output = wasmDis(ins.exports[export_name], {tier:"ion", asString:true});
+
+    const expected_initial = expected;
+    if (!options.no_prefix)
+        expected = x86_prefix + '\n' + expected;
+    if (!options.no_suffix)
+        expected = expected + '\n' + x86_suffix;
+    expected = fixlines(expected);
+
+    const output_matches_expected = output.match(new RegExp(expected)) != null;
+    if (!output_matches_expected) {
+        print("---- codegen-x86-test.js: TEST FAILED ----");
+    }
+    if (options.log && output_matches_expected) {
+        print("---- codegen-x86-test.js: TEST PASSED ----");
+    }
+    if (options.log || !output_matches_expected) {
+        print("---- module text");
+        print(module_text);
+        print("---- actual");
+        print(output);
+        print("---- expected (initial)");
+        print(expected_initial);
+        print("---- expected (as used)");
+        print(expected);
+        print("----");
+    }
+
+    assertEq(output_matches_expected, true);
+}
+
diff --git a/js/src/jit-test/lib/dataview.js b/js/src/jit-test/lib/dataview.js
new file mode 100644
index 0000000000..68228f324b
--- /dev/null
+++ b/js/src/jit-test/lib/dataview.js
@@ -0,0 +1,82 @@
+function typeName(typedArrayCtor) {
+  return typedArrayCtor.name.slice(0, -"Array".length);
+}
+
+const nativeIsLittleEndian = new Uint8Array(new Uint16Array([1]).buffer)[0] === 1;
+
+function toEndianess(type, v, littleEndian) {
+  // Disable Ion compilation to call the native, non-inlined DataView functions.
+  with ({}); // no-ion
+  assertEq(inIon() !== true, true);
+
+  let dv = new DataView(new ArrayBuffer(type.BYTES_PER_ELEMENT));
+
+  let name = typeName(type);
+  dv[`set${name}`](0, v, nativeIsLittleEndian);
+  return dv[`get${name}`](0, littleEndian);
+}
+
+function toLittleEndian(type, v) {
+  return toEndianess(type, v, true);
+}
+
+function toBigEndian(type, v) {
+  return toEndianess(type, v, false);
+}
+
+// Shared test data for various DataView tests.
+function createTestData() {
+  const tests = [
+    {
+      type: Int8Array,
+      values: [-128, -127, -2, -1, 0, 1, 2, 126, 127],
+    },
+    {
+      type: Uint8Array,
+      values: [0, 1, 2, 126, 127, 128, 254, 255],
+    },
+    {
+      type: Int16Array,
+      values: [-32768, -32767, -2, -1, 0, 1, 2, 32766, 32767],
+    },
+    {
+      type: Uint16Array,
+      values: [0, 1, 2, 32766, 32767, 32768, 65534, 65535],
+    },
+    {
+      type: Int32Array,
+      values: [-2147483648, -2147483647, -2, -1, 0, 1, 2, 2147483646, 2147483647],
+    },
+    {
+      type: Uint32Array,
+      values: [0, 1, 2, 2147483646, 2147483647],  // Representable as Int32
+    },
+    {
+      type: Uint32Array,
+      values: [0, 1, 2, 2147483646, 2147483647, 2147483648, 4294967294, 4294967295],
+    },
+    {
+      type: Float32Array,
+      values: [-NaN, -Infinity, -0.5, -0, +0, 0.5, Infinity, NaN],
+    },
+    {
+      type: Float64Array,
+      values: [-NaN, -Infinity, -0.5, -0, +0, 0.5, Infinity, NaN],
+    },
+    {
+      type: BigInt64Array,
+      values: [-9223372036854775808n, -9223372036854775807n, -2n, -1n, 0n, 1n, 2n, 9223372036854775806n, 9223372036854775807n],
+    },
+    {
+      type: BigUint64Array,
+      values: [0n, 1n, 2n, 9223372036854775806n, 9223372036854775807n, 9223372036854775808n, 18446744073709551614n, 18446744073709551615n],
+    },
+  ];
+
+  tests.forEach(data => {
+    data.littleEndian = data.values.map(v => toLittleEndian(data.type, v));
+    data.bigEndian = data.values.map(v => toBigEndian(data.type, v));
+  });
+
+  return tests;
+}
diff --git a/js/src/jit-test/lib/debuggerNXHelper.js b/js/src/jit-test/lib/debuggerNXHelper.js
new file mode 100644
index 0000000000..61792da84d
--- /dev/null
+++ b/js/src/jit-test/lib/debuggerNXHelper.js
@@ -0,0 +1,90 @@
+function testDebuggerHooksNX(dbg, g, testHook) {
+  function testDebuggerHook(hookName, trigger) {
+    var hit = false;
+    dbg[hookName] = () => {
+      hit = true;
+      dbg[hookName] = undefined;
+      testHook(hookName);
+    };
+    trigger();
+    assertEq(hit, true);
+  }
+
+  // Hooks on the Debugger instance itself.
+  testDebuggerHook("onDebuggerStatement",
+                   () => { g.eval("debugger;"); });
+
+  testDebuggerHook("onExceptionUnwind",
+                   () => {
+                     try {
+                       g.eval("throw 42;");
+                     } catch (e) {
+                       assertEq(e, 42);
+                     }
+                   });
+
+  testDebuggerHook("onNewScript",
+                   () => { g.eval("42"); });
+
+  testDebuggerHook("onEnterFrame",
+                   () => { g.eval("(() => {})()"); });
+
+  testDebuggerHook("onNewGlobalObject",
+                   () => { newGlobal(); });
+
+  if ('Promise' in g) {
+      testDebuggerHook("onNewPromise",
+                       () => { new g.Promise(()=>{}); });
+
+      testDebuggerHook("onPromiseSettled",
+                       () => {
+                         var p = new g.Promise(()=>{});
+                         g.settlePromiseNow(p);
+                       });
+  }
+
+  // Hooks on frames.
+  var onStepHit = false;
+  var onPopHit = false;
+  dbg.onEnterFrame = (frame) => {
+    dbg.onEnterFrame = undefined;
+
+    frame.onStep = () => {
+      onStepHit = true;
+      frame.onStep = undefined;
+      testHook("onStep");
+    };
+
+    frame.onPop = () => {
+      onPopHit = true;
+      testHook("onPop");
+    };
+  };
+  g.eval("42");
+  assertEq(onStepHit, true);
+
+  // We can't actually assert that onPop executed because there's one test
+  // that tests NX works across a removeDebuggee/addDebuggee toggle. The
+  // removeDebuggee purges D.F instances, so the onPop won't be called even
+  // when the global is re-added.
+  //assertEq(onPopHit, true);
+
+  // Breakpoints
+  var breakpointHits = 0;
+  dbg.onDebuggerStatement = (frame) => {
+    dbg.onDebuggerStatement = undefined;
+    var line0 = frame.script.getOffsetLocation(frame.offset).lineNumber;
+    var offs = frame.script.getLineOffsets(line0 + 1);
+    for (let i = 0; i < offs.length; i++) {
+      frame.script.setBreakpoint(offs[i], {
+        hit: () => {
+          breakpointHits++;
+          testHook("breakpoint");
+        }
+      });
+    }
+  };
+  g.eval(`debugger;
+         s = 'a'`);
+  assertEq(breakpointHits >= 1, true);
+}
diff --git a/js/src/jit-test/lib/eqArrayHelper.js b/js/src/jit-test/lib/eqArrayHelper.js
new file mode 100644
index 0000000000..389d3faa0a
--- /dev/null
+++ b/js/src/jit-test/lib/eqArrayHelper.js
@@ -0,0 +1,21 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+function assertEqArray(actual, expected) {
+    if (actual.length != expected.length) {
+        throw new Error(
+            "array lengths not equal: got " +
+            JSON.stringify(actual) + ", expected " + JSON.stringify(expected));
+    }
+
+    for (var i = 0; i < actual.length; ++i) {
+        if (actual[i] != expected[i]) {
+        throw new Error(
+            "arrays not equal at element " + i + ": got " +
+            JSON.stringify(actual) + ", expected " + JSON.stringify(expected));
+        }
+    }
+}
+
+
diff --git a/js/src/jit-test/lib/evalInFrame.js b/js/src/jit-test/lib/evalInFrame.js
new file mode 100644
index 0000000000..d429b3fb6a
--- /dev/null
+++ b/js/src/jit-test/lib/evalInFrame.js
@@ -0,0 +1,32 @@
+var evalInFrame = (function (global) {
+  var dbgGlobal = newGlobal({newCompartment: true});
+  var dbg = new dbgGlobal.Debugger();
+
+  return function evalInFrame(upCount, code) {
+    dbg.addDebuggee(global);
+
+    // Skip ourself.
+    var frame = dbg.getNewestFrame().older;
+    for (var i = 0; i < upCount; i++) {
+      if (!frame.older)
+        break;
+      frame = frame.older;
+    }
+
+    var completion = frame.eval(code);
+    if (completion.return) {
+      var v = completion.return;
+      if (typeof v === "object")
+        v = v.unsafeDereference();
+      return v;
+    }
+    if (completion.throw) {
+      var v = completion.throw;
+      if (typeof v === "object")
+        v = v.unsafeDereference();
+      throw v;
+    }
+    if (completion === null)
+      terminate();
+  };
+})(this);
diff --git a/js/src/jit-test/lib/immutable-prototype.js b/js/src/jit-test/lib/immutable-prototype.js
new file mode 100644
index 0000000000..75c1f4e3ca
--- /dev/null
+++ b/js/src/jit-test/lib/immutable-prototype.js
@@ -0,0 +1,4 @@
+function globalPrototypeChainIsMutable()
+{
+  return false;
+}
diff --git a/js/src/jit-test/lib/iteration.js b/js/src/jit-test/lib/iteration.js
new file mode 100644
index 0000000000..b679014f7d
--- /dev/null
+++ b/js/src/jit-test/lib/iteration.js
@@ -0,0 +1,30 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+
+load(libdir + "asserts.js");
+
+if (typeof assertIteratorResult === 'undefined') {
+    var assertIteratorResult = function assertIteratorResult(result, value, done) {
+        assertEq(typeof result, "object");
+        var expectedProps = ['done', 'value'];
+        var actualProps = Object.getOwnPropertyNames(result);
+        actualProps.sort(), expectedProps.sort();
+        assertDeepEq(actualProps, expectedProps);
+        assertDeepEq(result.value, value);
+        assertDeepEq(result.done, done);
+    }
+}
+
+if (typeof assertIteratorNext === 'undefined') {
+    var assertIteratorNext = function assertIteratorNext(iter, value) {
+        assertIteratorResult(iter.next(), value, false);
+    }
+}
+
+if (typeof assertIteratorDone === 'undefined') {
+    var assertIteratorDone = function assertIteratorDone(iter, value) {
+        assertIteratorResult(iter.next(), value, true);
+    }
+}
diff --git a/js/src/jit-test/lib/jitopts.js b/js/src/jit-test/lib/jitopts.js
new file mode 100644
index 0000000000..a66c02474b
--- /dev/null
+++ b/js/src/jit-test/lib/jitopts.js
@@ -0,0 +1,70 @@
+// These predicates are for tests that require a particular set of JIT options.
+
+// Check if toggles match. Useful for tests that shouldn't be run if a
+// different set of JIT toggles are set, since TBPL runs each jit-test
+// multiple times with a variety of flags.
+function jitTogglesMatch(opts) {
+  var currentOpts = getJitCompilerOptions();
+  for (var k in opts) {
+    if (k.indexOf(".enable") > 0 && opts[k] != currentOpts[k])
+      return false;
+  }
+  return true;
+}
+
+// Run fn under a particular set of JIT options.
+function withJitOptions(opts, fn) {
+  var oldOpts = getJitCompilerOptions();
+  for (var k in opts)
+    setJitCompilerOption(k, opts[k]);
+  try {
+    fn();
+  } finally {
+    for (var k in oldOpts)
+      setJitCompilerOption(k, oldOpts[k]);
+  }
+}
+
+// N.B. Ion opts *must come before* baseline opts because there's some kind of
+// "undo eager compilation" logic. If we don't set the baseline warmup-counter
+// *after* the Ion warmup-counter we end up setting the baseline warmup-counter
+// to be the default if we hit the "undo eager compilation" logic.
+var Opts_BaselineEager =
+    {
+      'ion.enable': 1,
+      'ion.warmup.trigger': 100,
+      'baseline.enable': 1,
+      'baseline.warmup.trigger': 0,
+      'offthread-compilation.enable': 1
+    };
+
+// Checking for offthread compilation being off is often helpful if the test
+// requires a function be Ion compiled. Each individual test will usually
+// finish before the Ion compilation thread has a chance to attach the
+// compiled code.
+var Opts_IonEagerNoOffthreadCompilation =
+    {
+      'ion.enable': 1,
+      'ion.warmup.trigger': 0,
+      'baseline.enable': 1,
+      'baseline.warmup.trigger': 0,
+      'offthread-compilation.enable': 0,
+    };
+
+var Opts_Ion2NoOffthreadCompilation =
+    {
+      'ion.enable': 1,
+      'ion.warmup.trigger': 3,
+      'baseline.enable': 1,
+      'baseline.warmup.trigger': 1,
+      'offthread-compilation.enable': 0
+    };
+
+var Opts_NoJits =
+    {
+      'ion.enable': 0,
+      'ion.warmup.trigger': 0,
+      'baseline.warmup.trigger': 0,
+      'baseline.enable': 0,
+      'offthread-compilation.enable': 0
+    };
diff --git a/js/src/jit-test/lib/match-debugger.js b/js/src/jit-test/lib/match-debugger.js
new file mode 100644
index 0000000000..19331a11fe
--- /dev/null
+++ b/js/src/jit-test/lib/match-debugger.js
@@ -0,0 +1,64 @@
+// Debugger-oriented Pattern subclasses.
+
+if (typeof Match !== 'function') {
+  load(libdir + 'match.js');
+}
+
+class DebuggerObjectPattern extends Match.Pattern {
+  constructor(className, props) {
+    super();
+    this.className = className;
+    if (props) {
+      this.props = Match.Pattern.OBJECT_WITH_EXACTLY(props);
+    }
+  }
+
+  match(actual) {
+    if (!(actual instanceof Debugger.Object)) {
+      throw new Match.MatchError(`Expected Debugger.Object, got ${actual}`);
+    }
+
+    if (actual.class !== this.className) {
+      throw new Match.MatchError(`Expected Debugger.Object of class ${this.className}, got Debugger.Object of class ${actual.class}`);
+    }
+
+    if (this.props !== undefined) {
+      const lifted = {};
+      for (const name of actual.getOwnPropertyNames()) {
+        const desc = actual.getOwnPropertyDescriptor(name);
+        if (!('value' in desc)) {
+          throw new Match.MatchError(`Debugger.Object referent has non-value property ${JSON.stringify(name)}`);
+        }
+        lifted[name] = desc.value;
+      }
+
+      try {
+        this.props.match(lifted);
+      } catch (inner) {
+        if (!(inner instanceof Match.MatchError)) {
+          throw inner;
+        }
+        inner.message = `matching Debugger.Object referent properties:\n${inner.message}`;
+        throw inner;
+      }
+    }
+
+    return true;
+  }
+}
+
+// The Debugger API guarantees that various sorts of meta-objects are 1:1 with
+// their referents, so it's often useful to check that two objects are === in
+// patterns.
+class DebuggerIdentical extends Match.Pattern {
+  constructor(expected) {
+    super();
+    this.expected = expected;
+  }
+
+  match(actual) {
+    if (actual !== this.expected) {
+      throw new Pattern.MatchError(`Expected exact value ${uneval(this.expected)}, got ${uneval(actual)}`);
+    }
+  }
+}
diff --git a/js/src/jit-test/lib/match.js b/js/src/jit-test/lib/match.js
new file mode 100644
index 0000000000..70cd15a5b5
--- /dev/null
+++ b/js/src/jit-test/lib/match.js
@@ -0,0 +1 @@
+loadRelativeToScript("../../tests/non262/reflect-parse/Match.js");
diff --git a/js/src/jit-test/lib/math.js b/js/src/jit-test/lib/math.js
new file mode 100644
index 0000000000..116ed477d8
--- /dev/null
+++ b/js/src/jit-test/lib/math.js
@@ -0,0 +1 @@
+loadRelativeToScript("../../tests/non262/Math/shell.js");
diff --git a/js/src/jit-test/lib/nightly-only.js b/js/src/jit-test/lib/nightly-only.js
new file mode 100644
index 0000000000..471a2d7431
--- /dev/null
+++ b/js/src/jit-test/lib/nightly-only.js
@@ -0,0 +1,23 @@
+// Some experimental features are enabled only on nightly builds, and disabled
+// on beta and release. Tests for these features should not simply disable
+// themselves on all but nightly builds, because if we neglect to update such
+// tests once the features cease to be experimental, we'll silently skip the
+// tests on beta and release, even though they should run.
+
+// Call the function f. On beta and release, expect it to throw an error that is
+// an instance of error.
+function nightlyOnly(error, f) {
+  if (getBuildConfiguration().release_or_beta) {
+    try {
+      f();
+      throw new Error("use of feature expected to fail on release and beta, but succeeded; please update test");
+    } catch (e) {
+      if (!(e instanceof error)) {
+        throw e;
+      }
+      // All is well.
+    }
+  } else {
+    f();
+  }
+}
diff --git a/js/src/jit-test/lib/non262.js b/js/src/jit-test/lib/non262.js
new file mode 100644
index 0000000000..e840038a7e
--- /dev/null
+++ b/js/src/jit-test/lib/non262.js
@@ -0,0 +1 @@
+loadRelativeToScript("../../tests/non262/shell.js");
diff --git a/js/src/jit-test/lib/orTestHelper.js b/js/src/jit-test/lib/orTestHelper.js
new file mode 100644
index 0000000000..bd54d7ac3b
--- /dev/null
+++ b/js/src/jit-test/lib/orTestHelper.js
@@ -0,0 +1,13 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+function orTestHelper(a, b, n)
+{
+  var k = 0;
+  for (var i = 0; i < n; i++) {
+    if (a || b)
+      k += i;
+  }
+  return k;
+}
diff --git a/js/src/jit-test/lib/pretenure.js b/js/src/jit-test/lib/pretenure.js
new file mode 100644
index 0000000000..85282680c0
--- /dev/null
+++ b/js/src/jit-test/lib/pretenure.js
@@ -0,0 +1,80 @@
+// Functions shared by gc/pretenure-*.js tests
+
+const is64bit = getBuildConfiguration()['pointer-byte-size'] === 8;
+
+// Count of objects that will exceed the size of the nursery.
+const nurseryCount = is64bit ? 25000 : 50000;
+
+// Count of objects that will exceed the tenured heap collection threshold.
+const tenuredCount = is64bit ? 300000 : 600000;
+
+function setupPretenureTest() {
+  // The test requires that baseline is enabled and is not bypassed with
+  // --ion-eager or similar.
+  let jitOptions = getJitCompilerOptions();
+  if (!jitOptions['baseline.enable'] ||
+      jitOptions['ion.warmup.trigger'] <= jitOptions['baseline.warmup.trigger']) {
+    print("Unsupported JIT options");
+    quit();
+  }
+
+  // Disable zeal modes that will interfere with this test.
+  gczeal(0);
+
+  // Restrict nursery size so we can fill it quicker, and ensure it is resized.
+  gcparam("minNurseryBytes", 1024 * 1024);
+  gcparam("maxNurseryBytes", 1024 * 1024);
+
+  // Limit allocation threshold so we trigger major GCs sooner.
+  gcparam("allocationThreshold", 1 /* MB */);
+
+  // Disable incremental GC so there's at most one minor GC per major GC.
+  gcparam("incrementalGCEnabled", false);
+
+  // Disable balanced heap limits to make the number of GCs predictable.
+  gcparam("balancedHeapLimitsEnabled", false);
+
+  // Force a nursery collection to apply size parameters.
+  let o = {};
+
+  gc();
+}
+
+function allocateObjects(count, longLived) {
+  let array = new Array(nurseryCount);
+  for (let i = 0; i < count; i++) {
+    let x = {x: i};
+    if (longLived) {
+      array[i % nurseryCount] = x;
+    } else {
+      array[0] = x;
+    }
+  }
+  return array;
+}
+
+function allocateArrays(count, longLived) {
+  let array = new Array(nurseryCount);
+  for (let i = 0; i < count; i++) {
+    let x = [i];
+    if (longLived) {
+      array[i % nurseryCount] = x;
+    } else {
+      array[0] = x;
+    }
+  }
+  return array;
+}
+
+function gcCounts() {
+  return { minor: gcparam("minorGCNumber"),
+           major: gcparam("majorGCNumber") };
+}
+
+function runTestAndCountCollections(thunk) {
+  let initialCounts = gcCounts();
+  thunk();
+  let finalCounts = gcCounts();
+  return { minor: finalCounts.minor - initialCounts.minor,
+           major: finalCounts.major - initialCounts.major };
+}
diff --git a/js/src/jit-test/lib/prologue.js b/js/src/jit-test/lib/prologue.js
new file mode 100644
index 0000000000..a632a7ba58
--- /dev/null
+++ b/js/src/jit-test/lib/prologue.js
@@ -0,0 +1,29 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+var appendToActual = function(s) {
+    actual += s + ',';
+}
+
+// Add dummy versions of missing functions and record whether they
+// were originally present.
+let hasFunction = {};
+for (const name of ["gczeal",
+                    "schedulegc",
+                    "gcslice",
+                    "selectforgc",
+                    "verifyprebarriers",
+                    "verifypostbarriers",
+                    "gcPreserveCode",
+                    "setMarkStackLimit"]) {
+    const present = name in this;
+    if (!present) {
+        this[name] = function() {};
+    }
+    hasFunction[name] = present;
+}
+
+// Set the minimum heap size for parallel marking to zero for testing purposes.
+gcparam('parallelMarkingThresholdKB', 0);
diff --git a/js/src/jit-test/lib/stepping.js b/js/src/jit-test/lib/stepping.js
new file mode 100644
index 0000000000..e9a47cd4f3
--- /dev/null
+++ b/js/src/jit-test/lib/stepping.js
@@ -0,0 +1,32 @@
+// Test that stepping through a function stops at the expected lines.
+// `script` is a string, some JS code that evaluates to a function.
+// `expected` is the array of line numbers where stepping is expected to stop
+// when we call the function.
+function testStepping(script, expected) {
+    let g = newGlobal({newCompartment: true});
+    let f = g.eval(script);
+
+    let log = [];
+    function maybePause(frame) {
+        let previousLine = log[log.length - 1]; // note: may be undefined
+        let line = frame.script.getOffsetLocation(frame.offset).lineNumber;
+        if (line !== previousLine)
+            log.push(line);
+    }
+
+    let dbg = new Debugger(g);
+    dbg.onEnterFrame = frame => {
+        // Log this pause (before the first instruction of the function).
+        maybePause(frame);
+
+        // Log future pauses in the same stack frame.
+        frame.onStep = function() { maybePause(this); };
+
+        // Now disable this hook so that we step over function calls, not into them.
+        dbg.onEnterFrame = undefined;
+    };
+
+    f();
+
+    assertEq(log.join(","), expected.join(","));
+}
diff --git a/js/src/jit-test/lib/string.js b/js/src/jit-test/lib/string.js
new file mode 100644
index 0000000000..15431ae2c1
--- /dev/null
+++ b/js/src/jit-test/lib/string.js
@@ -0,0 +1,24 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+
+if (typeof isHighSurrogate === 'undefined') {
+    var isHighSurrogate = function isHighSurrogate(s) {
+        var c = s.charCodeAt(0);
+        return c >= 0xD800 && c <= 0xDBFF;
+    }
+}
+
+if (typeof isLowSurrogate === 'undefined') {
+    var isLowSurrogate = function isLowSurrogate(s) {
+        var c = s.charCodeAt(0);
+        return c >= 0xDC00 && c <= 0xDFFF;
+    }
+}
+
+if (typeof isSurrogatePair === 'undefined') {
+    var isSurrogatePair = function isSurrogatePair(s) {
+        return s.length == 2 && isHighSurrogate(s[0]) && isLowSurrogate(s[1]);
+    }
+}
diff --git a/js/src/jit-test/lib/syntax.js b/js/src/jit-test/lib/syntax.js
new file mode 100644
index 0000000000..5afd1405fb
--- /dev/null
+++ b/js/src/jit-test/lib/syntax.js
@@ -0,0 +1,1284 @@
+function test_syntax(postfixes, check_error, ignore_opts) {
+  function test_reflect(code, module) {
+    var options = undefined;
+    if (module) {
+      options = {target: "module"};
+    }
+    for (var postfix of postfixes) {
+      var cur_code = code + postfix;
+
+      var caught = false;
+      try {
+        Reflect.parse(cur_code, options);
+      } catch (e) {
+        caught = true;
+        check_error(e, cur_code, "reflect");
+      }
+      assertEq(caught, true);
+    }
+  }
+
+  function test_eval(code) {
+    for (var postfix of postfixes) {
+      var cur_code = code + postfix;
+
+      var caught = false;
+      try {
+        eval(cur_code);
+      } catch (e) {
+        caught = true;
+        check_error(e, cur_code, "eval");
+      }
+      assertEq(caught, true);
+    }
+  }
+
+  function test(code, opts={}) {
+    if (ignore_opts) {
+      opts = {};
+    }
+
+    let no_strict = "no_strict" in opts && opts.no_strict;
+    let no_fun = "no_fun" in opts && opts.no_fun;
+    let no_eval = "no_eval" in opts && opts.no_eval;
+    let module = "module" in opts && opts.module;
+
+    test_reflect(code, module);
+    if (!no_strict) {
+      test_reflect("'use strict'; " + code, module);
+    }
+    if (!no_fun) {
+      test_reflect("(function() { " + code, module);
+      if (!no_strict) {
+        test_reflect("(function() { 'use strict'; " + code, module);
+      }
+    }
+
+    if (!no_eval) {
+      test_eval(code);
+      if (!no_strict) {
+        test_eval("'use strict'; " + code);
+      }
+      if (!no_fun) {
+        test_eval("(function() { " + code);
+        if (!no_strict) {
+          test_eval("(function() { 'use strict'; " + code);
+        }
+      }
+    }
+  }
+
+  function test_fun_arg(arg) {
+    for (var postfix of postfixes) {
+      var cur_arg = arg + postfix;
+
+      var caught = false;
+      try {
+        new Function(cur_arg, "");
+      } catch (e) {
+        caught = true;
+        check_error(e, cur_arg, "fun_arg");
+      }
+      assertEq(caught, true);
+    }
+  }
+
+  // ==== Statements and declarations ====
+
+  // ---- Control flow ----
+
+  // Block
+
+  test("{ ");
+  test("{ } ");
+
+  test("{ 1 ");
+  test("{ 1; ");
+  test("{ 1; } ");
+
+  // break
+
+  test("a: for (;;) { break ");
+  test("a: for (;;) { break; ");
+  test("a: for (;;) { break a ");
+  test("a: for (;;) { break a; ");
+
+  test("a: for (;;) { break\n");
+
+  // continue
+
+  test("a: for (;;) { continue ");
+  test("a: for (;;) { continue; ");
+  test("a: for (;;) { continue a ");
+  test("a: for (;;) { continue a; ");
+
+  test("a: for (;;) { continue\n");
+
+  // Empty
+
+  test("");
+  test("; ");
+
+  // if...else
+
+  test("if ");
+  test("if (");
+  test("if (x ");
+  test("if (x) ");
+  test("if (x) { ");
+  test("if (x) {} ");
+  test("if (x) {} else ");
+  test("if (x) {} else { ");
+  test("if (x) {} else {} ");
+  test("if (x) x ");
+  test("if (x) x; ");
+  test("if (x) x; else ");
+  test("if (x) x; else y ");
+  test("if (x) x; else y; ");
+
+  // switch
+
+  test("switch ");
+  test("switch (");
+  test("switch (x ");
+  test("switch (x) ");
+  test("switch (x) { ");
+  test("switch (x) { case ");
+  test("switch (x) { case 1 ");
+  test("switch (x) { case 1: ");
+  test("switch (x) { case 1: case ");
+  test("switch (x) { case 1: case 2 ");
+  test("switch (x) { case 1: case 2: ");
+  test("switch (x) { case 1: case 2: x ");
+  test("switch (x) { case 1: case 2: x; ");
+  test("switch (x) { case 1: case 2: x; break ");
+  test("switch (x) { case 1: case 2: x; break; ");
+  test("switch (x) { case 1: case 2: x; break; case ");
+  test("switch (x) { case 1: case 2: x; break; case 3 ");
+  test("switch (x) { case 1: case 2: x; break; case 3: y ");
+  test("switch (x) { case 1: case 2: x; break; case 3: y; ");
+  test("switch (x) { case 1: case 2: x; break; case 3: y; default ");
+  test("switch (x) { case 1: case 2: x; break; case 3: y; default: ");
+  test("switch (x) { case 1: case 2: x; break; case 3: y; default: z ");
+  test("switch (x) { case 1: case 2: x; break; case 3: y; default: z; ");
+  test("switch (x) { case 1: case 2: x; break; case 3: y; default: z; } ");
+
+  // throw
+
+  test("throw ");
+  test("throw x ");
+  test("throw x; ");
+
+  // try...catch
+
+  test("try ");
+  test("try { ");
+  test("try {} ");
+  test("try {} catch ");
+  test("try {} catch ( ");
+  test("try {} catch (e ");
+  test("try {} catch (e) ");
+  test("try {} catch (e) { ");
+  test("try {} catch (e) {} ");
+  test("try {} catch (e) {} finally ");
+  test("try {} catch (e) {} finally { ");
+  test("try {} catch (e) {} finally {} ");
+
+  // ---- Declarations ----
+
+  // var
+
+  test("var ");
+  test("var x ");
+  test("var x = ");
+  test("var x = 1 ");
+  test("var x = 1 + ");
+  test("var x = 1 + 2 ");
+  test("var x = 1 + 2, ");
+  test("var x = 1 + 2, y ");
+  test("var x = 1 + 2, y, ");
+  test("var x = 1 + 2, y, z ");
+  test("var x = 1 + 2, y, z; ");
+
+  test("var [ ");
+  test("var [ x ");
+  test("var [ x, ");
+  test("var [ x, ... ");
+  test("var { ");
+  test("var { x ");
+  test("var { x: ");
+  test("var { x: y ");
+  test("var { x: y, ");
+  test("var { x: y } ");
+  test("var { x: y } = ");
+
+  // let
+
+  test("let ");
+  test("let x ");
+  test("let x = ");
+  test("let x = 1 ");
+  test("let x = 1 + ");
+  test("let x = 1 + 2 ");
+  test("let x = 1 + 2, ");
+  test("let x = 1 + 2, y ");
+  test("let x = 1 + 2, y, ");
+  test("let x = 1 + 2, y, z ");
+  test("let x = 1 + 2, y, z; ");
+
+  test("let [ ");
+  test("let [ x ");
+  test("let [ x, ");
+  test("let [ x, ... ");
+  test("let { ");
+  test("let { x ");
+  test("let { x: ");
+  test("let { x: y ");
+  test("let { x: y, ");
+  test("let { x: y } ");
+  test("let { x: y } = ");
+
+  // const
+
+  test("const ");
+  test("const x ");
+  test("const x = ");
+  test("const x = 1 ");
+  test("const x = 1 + ");
+  test("const x = 1 + 2 ");
+  test("const x = 1 + 2, ");
+  test("const x = 1 + 2, y = 0");
+  test("const x = 1 + 2, y = 0, ");
+  test("const x = 1 + 2, y = 0, z = 0 ");
+  test("const x = 1 + 2, y = 0, z = 0; ");
+
+  test("const [ ");
+  test("const [ x ");
+  test("const [ x, ");
+  test("const [ x, ... ");
+  test("const { ");
+  test("const { x ");
+  test("const { x: ");
+  test("const { x: y ");
+  test("const { x: y, ");
+  test("const { x: y } ");
+  test("const { x: y } = ");
+
+  // ---- Functions ----
+
+  // function
+
+  test("function ");
+  test("function f ");
+  test("function f( ");
+  test("function f(x ");
+  test("function f(x, ");
+  test("function f(x, [ ");
+  test("function f(x, [y ");
+  test("function f(x, [y, ");
+  test("function f(x, [y, { ");
+  test("function f(x, [y, {z ");
+  test("function f(x, [y, {z: ");
+  test("function f(x, [y, {z: zz ");
+  test("function f(x, [y, {z: zz,  ");
+  test("function f(x, [y, {z: zz, w ");
+  test("function f(x, [y, {z: zz, w} ");
+  test("function f(x, [y, {z: zz, w}] ");
+  test("function f(x, [y, {z: zz, w}], ");
+  test("function f(x, [y, {z: zz, w}], v ");
+  test("function f(x, [y, {z: zz, w}], v= ");
+  test("function f(x, [y, {z: zz, w}], v=1 ");
+  test("function f(x, [y, {z: zz, w}], v=1, ");
+  test("function f(x, [y, {z: zz, w}], v=1, ... ");
+  test("function f(x, [y, {z: zz, w}], v=1, ...t ");
+  test("function f(x, [y, {z: zz, w}], v=1, ...t) ");
+  test("function f(x, [y, {z: zz, w}], v=1, ...t) {");
+  test("function f(x, [y, {z: zz, w}], v=1, ...t) { x ");
+  test("function f(x, [y, {z: zz, w}], v=1, ...t) { x; ");
+  test("function f(x, [y, {z: zz, w}], v=1, ...t) { x; } ");
+
+  // star function
+
+  test("function* ");
+  test("function* f ");
+  test("function* f( ");
+  test("function* f(x ");
+  test("function* f(x, ");
+  test("function* f(x, ... ");
+  test("function* f(x, ...t ");
+  test("function* f(x, ...t) ");
+  test("function* f(x, ...t) {");
+  test("function* f(x, ...t) { x ");
+  test("function* f(x, ...t) { x; ");
+  test("function* f(x, ...t) { x; } ");
+
+  // return
+
+  test("function f() { return ");
+  test("function f() { return 1 ");
+  test("function f() { return 1; ");
+  test("function f() { return 1; } ");
+  test("function f() { return; ");
+  test("function f() { return\n");
+
+  // yield
+
+  test("function* f() { yield ");
+  test("function* f() { yield 1 ");
+  test("function* f() { yield* ");
+  test("function* f() { yield* 1 ");
+
+  test("function* f() { yield\n");
+  test("function* f() { yield*\n");
+
+  // ---- Iterations ----
+
+  // do...while
+
+  test("do ");
+  test("do {");
+  test("do {} ");
+  test("do {} while ");
+  test("do {} while ( ");
+  test("do {} while (x ");
+  test("do {} while (x) ");
+  test("do {} while (x); ");
+
+  test("do x ");
+  test("do x; ");
+  test("do x; while ");
+
+  // for
+
+  test("for ");
+  test("for (");
+  test("for (x ");
+  test("for (x; ");
+  test("for (x; y ");
+  test("for (x; y; ");
+  test("for (x; y; z ");
+  test("for (x; y; z) ");
+  test("for (x; y; z) { ");
+  test("for (x; y; z) {} ");
+
+  test("for (x; y; z) x ");
+  test("for (x; y; z) x; ");
+
+  test("for (var ");
+  test("for (var x ");
+  test("for (var x = ");
+  test("for (var x = y ");
+  test("for (var x = y; ");
+
+  test("for (let ");
+  test("for (let x ");
+  test("for (let x = ");
+  test("for (let x = y ");
+  test("for (let x = y; ");
+
+  // for...in
+
+  test("for (x in ");
+  test("for (x in y ");
+  test("for (x in y) ");
+
+  test("for (var x in ");
+  test("for (var x in y ");
+  test("for (var x in y) ");
+
+  test("for (let x in ");
+  test("for (let x in y ");
+  test("for (let x in y) ");
+
+  // for...of
+
+  test("for (x of ");
+  test("for (x of y ");
+  test("for (x of y) ");
+
+  test("for (var x of ");
+  test("for (var x of y ");
+  test("for (var x of y) ");
+
+  test("for (let x of ");
+  test("for (let x of y ");
+  test("for (let x of y) ");
+
+  // while
+
+  test("while ");
+  test("while (");
+  test("while (x ");
+  test("while (x) ");
+  test("while (x) { ");
+  test("while (x) {} ");
+
+  test("while (x) x ");
+  test("while (x) x; ");
+
+  // ---- Others ----
+
+  // debugger
+
+  test("debugger ");
+  test("debugger; ");
+
+  // export
+
+  var opts = { no_fun: true, no_eval: true, module: true };
+  test("export ", opts);
+  test("export { ", opts);
+  test("export { x ", opts);
+  test("export { x, ", opts);
+  test("export { x, y ", opts);
+  test("export { x, y as ", opts);
+  test("export { x, y as z ", opts);
+  test("export { x, y as z } ", opts);
+  test("export { x, y as z } from ", opts);
+  test("export { x, y as z } from 'a' ", opts);
+  test("export { x, y as z } from 'a'; ", opts);
+
+  test("export * ", opts);
+  test("export * from ", opts);
+  test("export * from 'a' ", opts);
+  test("export * from 'a'; ", opts);
+
+  test("export * ", opts);
+  test("export * as ", opts);
+  test("export * as ns ", opts);
+  test("export * as ns from ", opts);
+  test("export * as ns from 'a' ", opts);
+  test("export * as ns from 'a'; ", opts);
+
+  test("export function ", opts);
+  test("export function f ", opts);
+  test("export function f( ", opts);
+  test("export function f() ", opts);
+  test("export function f() { ", opts);
+  test("export function f() {} ", opts);
+  test("export function f() {}; ", opts);
+
+  test("export var ", opts);
+  test("export var a ", opts);
+  test("export var a = ", opts);
+  test("export var a = 1 ", opts);
+  test("export var a = 1, ", opts);
+  test("export var a = 1, b ", opts);
+  test("export var a = 1, b = ", opts);
+  test("export var a = 1, b = 2 ", opts);
+  test("export var a = 1, b = 2; ", opts);
+
+  test("export let ", opts);
+  test("export let a ", opts);
+  test("export let a = ", opts);
+  test("export let a = 1 ", opts);
+  test("export let a = 1, ", opts);
+  test("export let a = 1, b ", opts);
+  test("export let a = 1, b = ", opts);
+  test("export let a = 1, b = 2 ", opts);
+  test("export let a = 1, b = 2; ", opts);
+
+  test("export const ", opts);
+  test("export const a ", opts);
+  test("export const a = ", opts);
+  test("export const a = 1 ", opts);
+  test("export const a = 1, ", opts);
+  test("export const a = 1, b ", opts);
+  test("export const a = 1, b = ", opts);
+  test("export const a = 1, b = 2 ", opts);
+  test("export const a = 1, b = 2; ", opts);
+
+  test("export class ", opts);
+  test("export class Foo ", opts);
+  test("export class Foo {  ", opts);
+  test("export class Foo { constructor ", opts);
+  test("export class Foo { constructor( ", opts);
+  test("export class Foo { constructor() ", opts);
+  test("export class Foo { constructor() { ", opts);
+  test("export class Foo { constructor() {} ", opts);
+  test("export class Foo { constructor() {} } ", opts);
+  test("export class Foo { constructor() {} }; ", opts);
+
+  test("export default ", opts);
+  test("export default 1 ", opts);
+  test("export default 1; ", opts);
+
+  test("export default function ", opts);
+  test("export default function() ", opts);
+  test("export default function() { ", opts);
+  test("export default function() {} ", opts);
+  test("export default function() {}; ", opts);
+
+  test("export default function foo ", opts);
+  test("export default function foo( ", opts);
+  test("export default function foo() ", opts);
+  test("export default function foo() { ", opts);
+  test("export default function foo() {} ", opts);
+  test("export default function foo() {}; ", opts);
+
+  test("export default class ", opts);
+  test("export default class { ", opts);
+  test("export default class { constructor ", opts);
+  test("export default class { constructor( ", opts);
+  test("export default class { constructor() ", opts);
+  test("export default class { constructor() { ", opts);
+  test("export default class { constructor() {} ", opts);
+  test("export default class { constructor() {} } ", opts);
+  test("export default class { constructor() {} }; ", opts);
+
+  test("export default class Foo ", opts);
+  test("export default class Foo { ", opts);
+  test("export default class Foo { constructor ", opts);
+  test("export default class Foo { constructor( ", opts);
+  test("export default class Foo { constructor() ", opts);
+  test("export default class Foo { constructor() { ", opts);
+  test("export default class Foo { constructor() {} ", opts);
+  test("export default class Foo { constructor() {} } ", opts);
+  test("export default class Foo { constructor() {} }; ", opts);
+
+  // import
+
+  test("import ", opts);
+  test("import x ", opts);
+  test("import x from ", opts);
+  test("import x from 'a' ", opts);
+  test("import x from 'a'; ", opts);
+
+  test("import { ", opts);
+  test("import { x ", opts);
+  test("import { x, ", opts);
+  test("import { x, y ", opts);
+  test("import { x, y } ", opts);
+  test("import { x, y } from ", opts);
+  test("import { x, y } from 'a' ", opts);
+  test("import { x, y } from 'a'; ", opts);
+
+  test("import { x as ", opts);
+  test("import { x as y ", opts);
+  test("import { x as y } ", opts);
+  test("import { x as y } from ", opts);
+  test("import { x as y } from 'a' ", opts);
+  test("import { x as y } from 'a'; ", opts);
+
+  test("import 'a' ", opts);
+  test("import 'a'; ", opts);
+
+  test("import * ", opts);
+  test("import * as ", opts);
+  test("import * as a ", opts);
+  test("import * as a from ", opts);
+  test("import * as a from 'a' ", opts);
+  test("import * as a from 'a'; ", opts);
+
+  test("import a ", opts);
+  test("import a, ", opts);
+  test("import a, * ", opts);
+  test("import a, * as ", opts);
+  test("import a, * as b ", opts);
+  test("import a, * as b from ", opts);
+  test("import a, * as b from 'c' ", opts);
+  test("import a, * as b from 'c'; ", opts);
+
+  test("import a, { ", opts);
+  test("import a, { b ", opts);
+  test("import a, { b } ", opts);
+  test("import a, { b } from ", opts);
+  test("import a, { b } from 'c' ", opts);
+  test("import a, { b } from 'c'; ", opts);
+
+  // label
+
+  test("a ");
+  test("a: ");
+
+  // with
+
+  opts = { no_strict: true };
+  test("with ", opts);
+  test("with (", opts);
+  test("with (x ", opts);
+  test("with (x) ", opts);
+  test("with (x) { ", opts);
+  test("with (x) {} ", opts);
+
+  test("with (x) x ", opts);
+  test("with (x) x; ", opts);
+
+  // ==== Expressions and operators ====
+
+  // ---- Primary expressions ----
+
+  // this
+
+  test("this ");
+
+  // function
+
+  test("(function ");
+  test("(function ( ");
+  test("(function (x ");
+  test("(function (x, ");
+  test("(function (x, ... ");
+  test("(function (x, ...t ");
+  test("(function (x, ...t) ");
+  test("(function (x, ...t) {");
+  test("(function (x, ...t) { x ");
+  test("(function (x, ...t) { x; ");
+  test("(function (x, ...t) { x; } ");
+  test("(function (x, ...t) { x; }) ");
+
+  // star function
+
+  test("(function* ");
+  test("(function* ( ");
+  test("(function* (x ");
+  test("(function* (x, ");
+  test("(function* (x, ... ");
+  test("(function* (x, ...t ");
+  test("(function* (x, ...t) ");
+  test("(function* (x, ...t) {");
+  test("(function* (x, ...t) { x ");
+  test("(function* (x, ...t) { x; ");
+  test("(function* (x, ...t) { x; } ");
+  test("(function* (x, ...t) { x; }) ");
+
+  // Array literal
+
+  test("[ ");
+  test("[] ");
+  test("[1 ");
+  test("[1, ");
+  test("[1, ... ");
+  test("[1, ...x ");
+  test("[1, ...x] ");
+
+  // object
+
+  test("({ ");
+  test("({ x ");
+  test("({ x: ");
+  test("({ x: 1 ");
+  test("({ x: 1, ");
+  test("({ x: 1, y ");
+  test("({ x: 1, y: ");
+  test("({ x: 1, y: 2 ");
+  test("({ x: 1, y: 2, ");
+  test("({ x: 1, y: 2, z ");
+  test("({ x: 1, y: 2, z, ");
+  test("({ x: 1, y: 2, z, w ");
+  test("({ x: 1, y: 2, z, w } ");
+  test("({ x: 1, y: 2, z, w }) ");
+
+  // object: computed property
+
+  test("({ [");
+  test("({ [k ");
+  test("({ [k] ");
+  test("({ [k]: ");
+  test("({ [k]: 1 ");
+  test("({ [k]: 1, ");
+
+  // object: getter
+
+  test("({ get ");
+  test("({ get p ");
+  test("({ get p( ");
+  test("({ get p() ");
+  test("({ get p() { ");
+  test("({ get p() {} ");
+  test("({ get p() {}, ");
+  test("({ get p() {}, } ");
+
+  test("({ get [ ");
+  test("({ get [p ");
+  test("({ get [p] ");
+  test("({ get [p]( ");
+  test("({ get [p]() ");
+
+  // object: setter
+
+  test("({ set ");
+  test("({ set p ");
+  test("({ set p( ");
+  test("({ set p(v ");
+  test("({ set p(v) ");
+  test("({ set p(v) { ");
+  test("({ set p(v) {} ");
+
+  test("({ set [ ");
+  test("({ set [p ");
+  test("({ set [p] ");
+  test("({ set [p]( ");
+  test("({ set [p](v ");
+  test("({ set [p](v) ");
+
+  // object: method
+
+  test("({ m ");
+  test("({ m( ");
+  test("({ m() ");
+  test("({ m() { ");
+  test("({ m() {} ");
+  test("({ m() {}, ");
+
+  test("({ [ ");
+  test("({ [m ");
+  test("({ [m] ");
+  test("({ [m]( ");
+  test("({ [m]() ");
+  test("({ [m]() { ");
+  test("({ [m]() {} ");
+  test("({ [m]() {}, ");
+
+  test("({ * ");
+  test("({ *m ");
+  test("({ *m( ");
+  test("({ *m() ");
+  test("({ *m() { ");
+  test("({ *m() {} ");
+  test("({ *m() {}, ");
+
+  test("({ *[ ");
+  test("({ *[m ");
+  test("({ *[m] ");
+  test("({ *[m]( ");
+  test("({ *[m]() ");
+  test("({ *[m]() { ");
+  test("({ *[m]() {} ");
+  test("({ *[m]() {}, ");
+
+  test("({ * get ");
+  test("({ * get ( ");
+  test("({ * get () ");
+  test("({ * get () { ");
+  test("({ * get () {} ");
+  test("({ * get () {}, ");
+
+  test("({ * set ");
+  test("({ * set ( ");
+  test("({ * set () ");
+  test("({ * set () { ");
+  test("({ * set () {} ");
+  test("({ * set () {}, ");
+
+  // Regular expression literal
+
+  test("/a/ ");
+  test("/a/g ");
+
+  // ---- Left-hand-side expressions ----
+
+  // property access
+
+  test("a[ ");
+  test("a[1 ");
+  test("a[1] ");
+
+  test("a. ");
+  test("a.b ");
+  test("a.b; ");
+
+  // new
+
+  test("new ");
+  test("new f ");
+  test("new f( ");
+  test("new f() ");
+  test("new f(); ");
+
+  // ---- Increment and decrement ----
+
+  test("a ++ ");
+  test("a ++; ");
+
+  test("-- ");
+  test("-- a ");
+  test("-- a; ");
+
+  // ---- Unary operators ----
+
+  // delete
+
+  test("delete ");
+  test("delete a ");
+  test("delete a[ ");
+  test("delete a[b ");
+  test("delete a[b] ");
+  test("delete a[b]; ");
+
+  test("delete ( ");
+  test("delete (a ");
+  test("delete (a[ ");
+  test("delete (a[b ");
+  test("delete (a[b] ");
+  test("delete (a[b]) ");
+  test("delete (a[b]); ");
+
+  // void
+
+  test("void ");
+  test("void a ");
+  test("void a; ");
+
+  test("void (");
+  test("void (a ");
+  test("void (a) ");
+  test("void (a); ");
+
+  // typeof
+
+  test("typeof ");
+  test("typeof a ");
+  test("typeof a; ");
+
+  test("typeof (");
+  test("typeof (a ");
+  test("typeof (a) ");
+  test("typeof (a); ");
+
+  // -
+
+  test("- ");
+  test("- 1 ");
+  test("- 1; ");
+
+  // +
+
+  test("+ ");
+  test("+ 1 ");
+  test("+ 1; ");
+
+  // ---- Arithmetic operators ----
+
+  // +
+
+  test("1 + ");
+  test("1 + 1 ");
+  test("1 + 1; ");
+
+  // ---- Relational operators ----
+
+  // in
+
+  test("a in ");
+  test("a in b ");
+  test("a in b; ");
+
+  // instanceof
+
+  test("a instanceof ");
+  test("a instanceof b ");
+  test("a instanceof b; ");
+
+  // ---- Equality operators ----
+
+  // ==
+
+  test("1 == ");
+  test("1 == 1 ");
+  test("1 == 1; ");
+
+  // ---- Bitwise shift operators ----
+
+  // <<
+
+  test("1 << ");
+  test("1 << 1 ");
+  test("1 << 1; ");
+
+  // ---- Binary bitwise operators ----
+
+  // &
+
+  test("1 & ");
+  test("1 & 1 ");
+  test("1 & 1; ");
+
+  // ---- Binary logical operators ----
+
+  // ||
+
+  test("1 || ");
+  test("1 || 1 ");
+  test("1 || 1; ");
+
+  // ---- Conditional (ternary) operator ----
+
+  test("1 ? ");
+  test("1 ? 2 ");
+  test("1 ? 2 : ");
+  test("1 ? 2 : 3 ");
+  test("1 ? 2 : 3; ");
+
+  // ---- Assignment operators ----
+
+  test("x = ");
+  test("x = 1 ");
+  test("x = 1 + ");
+  test("x = 1 + 2 ");
+  test("x = 1 + 2; ");
+
+  // ---- Comma operator ----
+
+  test("1, ");
+  test("1, 2 ");
+  test("1, 2; ");
+
+  // ---- Functions ----
+
+  // Arrow functions
+
+  test("a => ");
+  test("a => 1 ");
+  test("a => 1; ");
+  test("a => { ");
+  test("a => {} ");
+  test("a => {}; ");
+
+  test("( ");
+  test("() ");
+  test("() => ");
+
+  test("(...");
+  test("(...a ");
+  test("(...a) ");
+  test("(...a) => ");
+
+  test("([ ");
+  test("([a ");
+  test("([a] ");
+  test("([a]) ");
+  test("([a]) => ");
+
+  test("({ ");
+  test("({a ");
+  test("({a} ");
+  test("({a}) ");
+  test("({a}) => ");
+  test("({a: ");
+  test("({a: b ");
+  test("({a: b, ");
+  test("({a: b} ");
+  test("({a: b}) ");
+  test("({a: b}) => ");
+
+  // ---- Class declaration ----
+
+  test("class ");
+  test("class a ");
+  test("class a { ");
+  test("class a { constructor ");
+  test("class a { constructor( ");
+  test("class a { constructor() ");
+  test("class a { constructor() { ");
+  test("class a { constructor() { } ");
+  test("class a { constructor() { } } ");
+
+  test("class a { constructor() { } static ");
+  test("class a { constructor() { } static m ");
+  test("class a { constructor() { } static m( ");
+  test("class a { constructor() { } static m() ");
+  test("class a { constructor() { } static m() { ");
+  test("class a { constructor() { } static m() {} ");
+  test("class a { constructor() { } static m() {} } ");
+
+  test("class a { constructor() { } static ( ");
+  test("class a { constructor() { } static () ");
+  test("class a { constructor() { } static () { ");
+  test("class a { constructor() { } static () {} ");
+  test("class a { constructor() { } static () {} } ");
+
+  test("class a { constructor() { } static get ");
+  test("class a { constructor() { } static get p ");
+  test("class a { constructor() { } static get p( ");
+  test("class a { constructor() { } static get p() ");
+  test("class a { constructor() { } static get p() { ");
+  test("class a { constructor() { } static get p() {} ");
+  test("class a { constructor() { } static get p() {} } ");
+
+  test("class a { constructor() { } static set ");
+  test("class a { constructor() { } static set p ");
+  test("class a { constructor() { } static set p( ");
+  test("class a { constructor() { } static set p(v ");
+  test("class a { constructor() { } static set p(v) ");
+  test("class a { constructor() { } static set p(v) { ");
+  test("class a { constructor() { } static set p(v) {} ");
+  test("class a { constructor() { } static set p(v) {} } ");
+
+  test("class a { constructor() { } * ");
+  test("class a { constructor() { } *m ");
+  test("class a { constructor() { } *m( ");
+  test("class a { constructor() { } *m() ");
+  test("class a { constructor() { } *m() { ");
+  test("class a { constructor() { } *m() {} ");
+  test("class a { constructor() { } *m() {} } ");
+
+  test("class a { constructor() { } static * ");
+  test("class a { constructor() { } static *m ");
+  test("class a { constructor() { } static *m( ");
+  test("class a { constructor() { } static *m() ");
+  test("class a { constructor() { } static *m() { ");
+  test("class a { constructor() { } static *m() {} ");
+  test("class a { constructor() { } static *m() {} } ");
+
+  test("class a extends ");
+  test("class a extends b ");
+  test("class a extends b { ");
+
+  test("class a extends ( ");
+  test("class a extends ( b ");
+  test("class a extends ( b ) ");
+  test("class a extends ( b ) { ");
+
+  // ---- Class expression ----
+
+  test("( class ");
+  test("( class a ");
+  test("( class a { ");
+  test("( class a { constructor ");
+  test("( class a { constructor( ");
+  test("( class a { constructor() ");
+  test("( class a { constructor() { ");
+  test("( class a { constructor() { } ");
+  test("( class a { constructor() { } } ");
+  test("( class a { constructor() { } } ) ");
+
+  test("(class a extends ");
+  test("(class a extends b ");
+  test("(class a extends b { ");
+
+  test("(class a extends ( ");
+  test("(class a extends ( b ");
+  test("(class a extends ( b ) ");
+  test("(class a extends ( b ) { ");
+
+  test("( class { ");
+  test("( class { constructor ");
+  test("( class { constructor( ");
+  test("( class { constructor() ");
+  test("( class { constructor() { ");
+  test("( class { constructor() { } ");
+  test("( class { constructor() { } } ");
+  test("( class { constructor() { } } ) ");
+
+  test("(class extends ");
+  test("(class extends b ");
+  test("(class extends b { ");
+
+  test("(class extends ( ");
+  test("(class extends ( b ");
+  test("(class extends ( b ) ");
+  test("(class extends ( b ) { ");
+
+  // ---- Other ----
+
+  // Literals
+
+  test("a ");
+  test("1 ");
+  test("1. ");
+  test("1.2 ");
+  test("true ");
+  test("false ");
+  test("\"a\" ");
+  test("'a' ");
+  test("null ");
+
+  // Template strings
+
+  test("`${ ");
+  test("`${a ");
+  test("`${a}` ");
+
+  // Function calls
+
+  test("f( ");
+  test("f() ");
+  test("f(); ");
+
+  test("f(... ");
+  test("f(...x ");
+  test("f(...x) ");
+
+  // Function constructors
+
+  test_fun_arg("");
+  test_fun_arg("a ");
+  test_fun_arg("... ");
+  test_fun_arg("...a ");
+
+  // ==== Legacy ====
+
+  // ==== asm.js ====
+
+  test("(function() { 'use asm'; ");
+  test("(function() { 'use asm'; var ");
+  test("(function() { 'use asm'; var a ");
+  test("(function() { 'use asm'; var a = ");
+  test("(function() { 'use asm'; var a = 1 ");
+  test("(function() { 'use asm'; var a = 1; ");
+  test("(function() { 'use asm'; var a = 1; function ");
+  test("(function() { 'use asm'; var a = 1; function f ");
+  test("(function() { 'use asm'; var a = 1; function f( ");
+  test("(function() { 'use asm'; var a = 1; function f() ");
+  test("(function() { 'use asm'; var a = 1; function f() { ");
+  test("(function() { 'use asm'; var a = 1; function f() { } ");
+  test("(function() { 'use asm'; var a = 1; function f() { } var ");
+  test("(function() { 'use asm'; var a = 1; function f() { } var tbl ");
+  test("(function() { 'use asm'; var a = 1; function f() { } var tbl = ");
+  test("(function() { 'use asm'; var a = 1; function f() { } var tbl = [ ");
+  test("(function() { 'use asm'; var a = 1; function f() { } var tbl = [f ");
+  test("(function() { 'use asm'; var a = 1; function f() { } var tbl = [f] ");
+  test("(function() { 'use asm'; var a = 1; function f() { } var tbl = [f]; ");
+  test("(function() { 'use asm'; var a = 1; function f() { } var tbl = [f]; return ");
+  test("(function() { 'use asm'; var a = 1; function f() { } var tbl = [f]; return f ");
+  test("(function() { 'use asm'; var a = 1; function f() { } var tbl = [f]; return f; ");
+  test("(function() { 'use asm'; var a = 1; function f() { } var tbl = [f]; return f; } ");
+  test("(function() { 'use asm'; var a = 1; function f() { } var tbl = [f]; return f; }) ");
+  test("(function() { 'use asm'; var a = 1; function f() { } var tbl = [f]; return f; }); ");
+
+  // ==== async/await ====
+
+  // async/await function decralation
+
+  test("async ");
+  test("async function ");
+  test("async function A ");
+  test("async function A( ");
+  test("async function A() ");
+  test("async function A(a ");
+  test("async function A(a) ");
+  test("async function A(a) { ");
+  test("async function A(a) {} ");
+  test("async function A(a) { await ");
+  test("async function A(a) { await X ");
+  test("async function A(a) { await X; ");
+  test("async function A(a) { await X; } ");
+  test("async function A(a) { await await ");
+  test("async function A(a) { await await await ");
+  test("async function A(a) { await await await X ");
+  test("async function A(a) { await await await X; ");
+  test("async function A(a) { await await await X; } ");
+
+  opts = { no_fun: true, no_eval: true, module: true };
+  test("export default async ", opts);
+  test("export default async function ", opts);
+  test("export default async function ( ", opts);
+  test("export default async function () ", opts);
+  test("export default async function (a ", opts);
+  test("export default async function (a) ", opts);
+  test("export default async function (a) { ", opts);
+  test("export default async function (a) {} ", opts);
+  test("export default async function (a) { await ", opts);
+  test("export default async function (a) { await X ", opts);
+  test("export default async function (a) { await X; ", opts);
+  test("export default async function (a) { await X; } ", opts);
+
+  // async/await function expression
+
+  test("(async ");
+  test("(async function ");
+  test("(async function A ");
+  test("(async function A( ");
+  test("(async function A() ");
+  test("(async function A(a ");
+  test("(async function A(a) ");
+  test("(async function A(a) { ");
+  test("(async function A(a) {} ");
+  test("(async function A(a) { await ");
+  test("(async function A(a) { await X ");
+  test("(async function A(a) { await X; ");
+  test("(async function A(a) { await X; } ");
+  test("(async function A(a) { await X; }) ");
+
+  test("(async function ( ");
+  test("(async function () ");
+  test("(async function (a ");
+  test("(async function (a) ");
+  test("(async function (a) { ");
+  test("(async function (a) {} ");
+  test("(async function (a) { await ");
+  test("(async function (a) { await X ");
+  test("(async function (a) { await X; ");
+  test("(async function (a) { await X; } ");
+  test("(async function (a) { await X; }) ");
+
+  // async/await method
+
+  test("({ async ");
+  test("({ async m ");
+  test("({ async m( ");
+  test("({ async m() ");
+  test("({ async m() { ");
+  test("({ async m() {} ");
+  test("({ async m() {}, ");
+
+  test("class X { async ");
+  test("class X { async m ");
+  test("class X { async m( ");
+  test("class X { async m() ");
+  test("class X { async m() { ");
+  test("class X { async m() {} ");
+
+  test("class X { static async ");
+  test("class X { static async m ");
+  test("class X { static async m( ");
+  test("class X { static async m() ");
+  test("class X { static async m() { ");
+  test("class X { static async m() {} ");
+
+  // async/await arrow
+
+  test("(async a ");
+  test("(async a => ");
+  test("(async a => b ");
+  test("(async a => b) ");
+
+  test("(async a => { ");
+  test("(async a => { b ");
+  test("(async a => { b } ");
+  test("(async a => { b }) ");
+
+  test("(async ( ");
+  test("(async (a ");
+  test("(async (a) ");
+  test("(async (a) => ");
+  test("(async (a) => b ");
+  test("(async (a) => b) ");
+  test("(async (a, ");
+  test("(async (a, b ");
+  test("(async (a, b) ");
+  test("(async (a, b) => ");
+  test("(async (a, b) => b ");
+  test("(async (a, b) => b) ");
+
+  test("(async ([ ");
+  test("(async ([a ");
+  test("(async ([a] ");
+  test("(async ([a]) ");
+  test("(async ([a]) => ");
+  test("(async ([a]) => b ");
+  test("(async ([a]) => b) ");
+  test("(async ([a, ");
+  test("(async ([a, b ");
+  test("(async ([a, b] ");
+  test("(async ([a, b]) ");
+  test("(async ([a, b]) => ");
+  test("(async ([a, b]) => b ");
+  test("(async ([a, b]) => b) ");
+
+  test("(async ({ ");
+  test("(async ({a ");
+  test("(async ({a} ");
+  test("(async ({a}) ");
+  test("(async ({a}) => ");
+  test("(async ({a}) => b ");
+  test("(async ({a}) => b) ");
+  test("(async ({a, ");
+  test("(async ({a, b ");
+  test("(async ({a, b} ");
+  test("(async ({a, b}) ");
+  test("(async ({a, b}) => ");
+  test("(async ({a, b}) => b ");
+  test("(async ({a, b}) => b) ");
+}
diff --git a/js/src/jit-test/lib/wasm-binary.js b/js/src/jit-test/lib/wasm-binary.js
new file mode 100644
index 0000000000..93ddc0571d
--- /dev/null
+++ b/js/src/jit-test/lib/wasm-binary.js
@@ -0,0 +1,555 @@
+// MagicNumber = 0x6d736100;
+const magic0 = 0x00;  // '\0'
+const magic1 = 0x61;  // 'a'
+const magic2 = 0x73;  // 's'
+const magic3 = 0x6d;  // 'm'
+
+// EncodingVersion
+const encodingVersion = 0x1;
+const ver0 = (encodingVersion >>>  0) & 0xff;
+const ver1 = (encodingVersion >>>  8) & 0xff;
+const ver2 = (encodingVersion >>> 16) & 0xff;
+const ver3 = (encodingVersion >>> 24) & 0xff;
+
+// Section opcodes
+const userDefinedId    = 0;
+const typeId           = 1;
+const importId         = 2;
+const functionId       = 3;
+const tableId          = 4;
+const memoryId         = 5;
+const globalId         = 6;
+const exportId         = 7;
+const startId          = 8;
+const elemId           = 9;
+const codeId           = 10;
+const dataId           = 11;
+const dataCountId      = 12;
+const tagId            = 13;
+
+// User-defined section names
+const nameName         = "name";
+
+// Name section name types
+const nameTypeModule    = 0;
+const nameTypeFunction  = 1;
+const nameTypeLocal     = 2;
+const nameTypeTag       = 3;
+
+// Type codes
+const I32Code          = 0x7f;
+const I64Code          = 0x7e;
+const F32Code          = 0x7d;
+const F64Code          = 0x7c;
+const V128Code         = 0x7b;
+const AnyFuncCode      = 0x70;
+const ExternRefCode    = 0x6f;
+const EqRefCode        = 0x6d;
+const OptRefCode       = 0x6c;
+const FuncCode         = 0x60;
+const VoidCode         = 0x40;
+
+// Opcodes
+const UnreachableCode  = 0x00
+const BlockCode        = 0x02;
+const TryCode          = 0x06;
+const CatchCode        = 0x07;
+const ThrowCode        = 0x08;
+const RethrowCode      = 0x09;
+const EndCode          = 0x0b;
+const ReturnCode       = 0x0f;
+const CallCode         = 0x10;
+const CallIndirectCode = 0x11;
+const DelegateCode     = 0x18;
+const DropCode         = 0x1a;
+const SelectCode       = 0x1b;
+const LocalGetCode     = 0x20;
+const I32Load          = 0x28;
+const I64Load          = 0x29;
+const F32Load          = 0x2a;
+const F64Load          = 0x2b;
+const I32Load8S        = 0x2c;
+const I32Load8U        = 0x2d;
+const I32Load16S       = 0x2e;
+const I32Load16U       = 0x2f;
+const I64Load8S        = 0x30;
+const I64Load8U        = 0x31;
+const I64Load16S       = 0x32;
+const I64Load16U       = 0x33;
+const I64Load32S       = 0x34;
+const I64Load32U       = 0x35;
+const I32Store         = 0x36;
+const I64Store         = 0x37;
+const F32Store         = 0x38;
+const F64Store         = 0x39;
+const I32Store8        = 0x3a;
+const I32Store16       = 0x3b;
+const I64Store8        = 0x3c;
+const I64Store16       = 0x3d;
+const I64Store32       = 0x3e;
+const GrowMemoryCode   = 0x40;
+const I32ConstCode     = 0x41;
+const I64ConstCode     = 0x42;
+const F32ConstCode     = 0x43;
+const F64ConstCode     = 0x44;
+const I32AddCode       = 0x6a;
+const I32DivSCode      = 0x6d;
+const I32DivUCode      = 0x6e;
+const I32RemSCode      = 0x6f;
+const I32RemUCode      = 0x70;
+const I32TruncSF32Code = 0xa8;
+const I32TruncUF32Code = 0xa9;
+const I32TruncSF64Code = 0xaa;
+const I32TruncUF64Code = 0xab;
+const I64TruncSF32Code = 0xae;
+const I64TruncUF32Code = 0xaf;
+const I64TruncSF64Code = 0xb0;
+const I64TruncUF64Code = 0xb1;
+const I64DivSCode      = 0x7f;
+const I64DivUCode      = 0x80;
+const I64RemSCode      = 0x81;
+const I64RemUCode      = 0x82;
+const RefNullCode      = 0xd0;
+const RefIsNullCode    = 0xd1;
+const RefFuncCode      = 0xd2;
+
+// SIMD opcodes
+const V128LoadCode = 0x00;
+const V128StoreCode = 0x0b;
+const I32x4DotSI16x8Code = 0xba;
+const F32x4CeilCode = 0xd8;
+const F32x4FloorCode = 0xd9;
+const F32x4TruncCode = 0xda;
+const F32x4NearestCode = 0xdb;
+const F64x2CeilCode = 0xdc;
+const F64x2FloorCode = 0xdd;
+const F64x2TruncCode = 0xde;
+const F64x2NearestCode = 0xdf;
+const F32x4PMinCode = 0xea;
+const F32x4PMaxCode = 0xeb;
+const F64x2PMinCode = 0xf6;
+const F64x2PMaxCode = 0xf7;
+const V128Load32ZeroCode = 0xfc;
+const V128Load64ZeroCode = 0xfd;
+
+// Relaxed SIMD opcodes.
+const I8x16RelaxedSwizzleCode = 0x100;
+const I32x4RelaxedTruncSSatF32x4Code = 0x101;
+const I32x4RelaxedTruncUSatF32x4Code = 0x102;
+const I32x4RelaxedTruncSatF64x2SZeroCode = 0x103;
+const I32x4RelaxedTruncSatF64x2UZeroCode = 0x104;
+const F32x4RelaxedFmaCode = 0x105;
+const F32x4RelaxedFnmaCode = 0x106;
+const F64x2RelaxedFmaCode = 0x107;
+const F64x2RelaxedFnmaCode = 0x108;
+const I8x16RelaxedLaneSelectCode = 0x109;
+const I16x8RelaxedLaneSelectCode = 0x10a;
+const I32x4RelaxedLaneSelectCode = 0x10b;
+const I64x2RelaxedLaneSelectCode = 0x10c;
+const F32x4RelaxedMinCode = 0x10d;
+const F32x4RelaxedMaxCode = 0x10e;
+const F64x2RelaxedMinCode = 0x10f;
+const F64x2RelaxedMaxCode = 0x110;
+const I16x8RelaxedQ15MulrS = 0x111;
+const I16x8DotI8x16I7x16S = 0x112;
+const I32x4DotI8x16I7x16AddS = 0x113;
+
+const FirstInvalidOpcode = 0xc5;
+const LastInvalidOpcode = 0xfa;
+const GcPrefix = 0xfb;
+const MiscPrefix = 0xfc;
+const SimdPrefix = 0xfd;
+const ThreadPrefix = 0xfe;
+const MozPrefix = 0xff;
+
+// See WasmConstants.h for documentation.
+// Limit this to a group of 8 per line.
+
+const definedOpcodes =
+    [0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
+     ...(wasmExceptionsEnabled() ? [0x06, 0x07, 0x08, 0x09] : []),
+     0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
+     0x10, 0x11,
+     ...(wasmFunctionReferencesEnabled() ? [0x14] : []),
+     ...(wasmExceptionsEnabled() ? [0x18, 0x19] : []),
+     0x1a, 0x1b, 0x1c,
+     0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26,
+     0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
+     0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
+     0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
+     0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
+     0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
+     0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
+     0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
+     0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
+     0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
+     0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
+     0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
+     0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
+     0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
+     0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
+     0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
+     0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
+     0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
+     0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
+     0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
+     0xc0, 0xc1, 0xc2, 0xc3, 0xc4,
+     0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
+     0xf0,
+     0xfb, 0xfc, 0xfd, 0xfe, 0xff ];
+
+const undefinedOpcodes = (function () {
+    let a = [];
+    let j = 0;
+    let i = 0;
+    while (i < 256) {
+        while (definedOpcodes[j] > i)
+            a.push(i++);
+        assertEq(definedOpcodes[j], i);
+        i++;
+        j++;
+    }
+    assertEq(definedOpcodes.length + a.length, 256);
+    return a;
+})();
+
+// Secondary opcode bytes for misc prefix
+const MemoryInitCode = 0x08;    // Pending
+const DataDropCode = 0x09;      // Pending
+const MemoryCopyCode = 0x0a;    // Pending
+const MemoryFillCode = 0x0b;    // Pending
+const TableInitCode = 0x0c;     // Pending
+const ElemDropCode = 0x0d;      // Pending
+const TableCopyCode = 0x0e;     // Pending
+
+const StructNew = 0x00;         // UNOFFICIAL
+const StructGet = 0x03;         // UNOFFICIAL
+const StructSet = 0x06;         // UNOFFICIAL
+
+// DefinitionKind
+const FunctionCode     = 0x00;
+const TableCode        = 0x01;
+const MemoryCode       = 0x02;
+const GlobalCode       = 0x03;
+const TagCode          = 0x04;
+
+// ResizableFlags
+const HasMaximumFlag   = 0x1;
+
+function toU8(array) {
+    for (let b of array)
+        assertEq(b < 256, true);
+    return Uint8Array.from(array);
+}
+
+function varU32(u32) {
+    assertEq(u32 >= 0, true);
+    assertEq(u32 < Math.pow(2,32), true);
+    var bytes = [];
+    do {
+        var byte = u32 & 0x7f;
+        u32 >>>= 7;
+        if (u32 != 0)
+            byte |= 0x80;
+        bytes.push(byte);
+    } while (u32 != 0);
+    return bytes;
+}
+
+function varS32(s32) {
+    assertEq(s32 >= -Math.pow(2,31), true);
+    assertEq(s32 < Math.pow(2,31), true);
+    var bytes = [];
+    do {
+        var byte = s32 & 0x7f;
+        s32 >>= 7;
+        if (s32 != 0 && s32 != -1)
+            byte |= 0x80;
+        bytes.push(byte);
+    } while (s32 != 0 && s32 != -1);
+    return bytes;
+}
+
+function moduleHeaderThen(...rest) {
+    return [magic0, magic1, magic2, magic3, ver0, ver1, ver2, ver3, ...rest];
+}
+
+function string(name) {
+    var nameBytes = name.split('').map(c => {
+        var code = c.charCodeAt(0);
+        assertEq(code < 128, true); // TODO
+        return code
+    });
+    return varU32(nameBytes.length).concat(nameBytes);
+}
+
+function encodedString(name, len) {
+    var name = unescape(encodeURIComponent(name)); // break into string of utf8 code points
+    var nameBytes = name.split('').map(c => c.charCodeAt(0)); // map to array of numbers
+    return varU32(len === undefined ? nameBytes.length : len).concat(nameBytes);
+}
+
+function moduleWithSections(sectionArray) {
+    var bytes = moduleHeaderThen();
+    for (let section of sectionArray) {
+        bytes.push(section.name);
+        bytes.push(...varU32(section.body.length));
+        bytes.push(...section.body);
+    }
+    return toU8(bytes);
+}
+
+function sigSection(sigs) {
+    var body = [];
+    body.push(...varU32(sigs.length));
+    for (let sig of sigs) {
+        body.push(...varU32(FuncCode));
+        body.push(...varU32(sig.args.length));
+        for (let arg of sig.args)
+            body.push(...varU32(arg));
+        if (sig.ret == VoidCode) {
+            body.push(...varU32(0));
+        } else if (typeof sig.ret == "number") {
+            body.push(...varU32(1));
+            body.push(...varU32(sig.ret));
+        } else {
+            body.push(...varU32(sig.ret.length));
+            for (let r of sig.ret)
+                body.push(...varU32(r));
+        }
+    }
+    return { name: typeId, body };
+}
+
+function declSection(decls) {
+    var body = [];
+    body.push(...varU32(decls.length));
+    for (let decl of decls)
+        body.push(...varU32(decl));
+    return { name: functionId, body };
+}
+
+function funcBody(func, withEndCode=true) {
+    var body = varU32(func.locals.length);
+    for (let local of func.locals)
+        body.push(...varU32(local));
+    body = body.concat(...func.body);
+    if (withEndCode)
+        body.push(EndCode);
+    body.splice(0, 0, ...varU32(body.length));
+    return body;
+}
+
+function bodySection(bodies) {
+    var body = varU32(bodies.length).concat(...bodies);
+    return { name: codeId, body };
+}
+
+function importSection(imports) {
+    var body = [];
+    body.push(...varU32(imports.length));
+    for (let imp of imports) {
+        body.push(...string(imp.module));
+        body.push(...string(imp.func));
+        body.push(...varU32(FunctionCode));
+        body.push(...varU32(imp.sigIndex));
+    }
+    return { name: importId, body };
+}
+
+function exportSection(exports) {
+    var body = [];
+    body.push(...varU32(exports.length));
+    for (let exp of exports) {
+        body.push(...string(exp.name));
+        if (exp.hasOwnProperty("funcIndex")) {
+            body.push(...varU32(FunctionCode));
+            body.push(...varU32(exp.funcIndex));
+        } else if (exp.hasOwnProperty("memIndex")) {
+            body.push(...varU32(MemoryCode));
+            body.push(...varU32(exp.memIndex));
+        } else if (exp.hasOwnProperty("tagIndex")) {
+            body.push(...varU32(TagCode));
+            body.push(...varU32(exp.tagIndex));
+        } else {
+            throw "Bad export " + exp;
+        }
+    }
+    return { name: exportId, body };
+}
+
+function tableSection(initialSize) {
+    var body = [];
+    body.push(...varU32(1));           // number of tables
+    body.push(...varU32(AnyFuncCode));
+    body.push(...varU32(0x0));         // for now, no maximum
+    body.push(...varU32(initialSize));
+    return { name: tableId, body };
+}
+
+function memorySection(initialSize) {
+    var body = [];
+    body.push(...varU32(1));           // number of memories
+    body.push(...varU32(0x0));         // for now, no maximum
+    body.push(...varU32(initialSize));
+    return { name: memoryId, body };
+}
+
+function tagSection(tags) {
+    var body = [];
+    body.push(...varU32(tags.length));
+    for (let tag of tags) {
+        body.push(...varU32(0)); // exception attribute
+        body.push(...varU32(tag.type));
+    }
+    return { name: tagId, body };
+}
+
+function dataSection(segmentArrays) {
+    var body = [];
+    body.push(...varU32(segmentArrays.length));
+    for (let array of segmentArrays) {
+        body.push(...varU32(0)); // table index
+        body.push(...varU32(I32ConstCode));
+        body.push(...varS32(array.offset));
+        body.push(...varU32(EndCode));
+        body.push(...varU32(array.elems.length));
+        for (let elem of array.elems)
+            body.push(...varU32(elem));
+    }
+    return { name: dataId, body };
+}
+
+function dataCountSection(count) {
+    var body = [];
+    body.push(...varU32(count));
+    return { name: dataCountId, body };
+}
+
+function globalSection(globalArray) {
+    var body = [];
+    body.push(...varU32(globalArray.length));
+    for (let globalObj of globalArray) {
+        // Value type
+        body.push(...varU32(globalObj.valType));
+        // Flags
+        body.push(globalObj.flags & 255);
+        // Initializer expression
+        body.push(...globalObj.initExpr);
+    }
+    return { name: globalId, body };
+}
+
+function elemSection(elemArrays) {
+    var body = [];
+    body.push(...varU32(elemArrays.length));
+    for (let array of elemArrays) {
+        body.push(...varU32(0)); // table index
+        body.push(...varU32(I32ConstCode));
+        body.push(...varS32(array.offset));
+        body.push(...varU32(EndCode));
+        body.push(...varU32(array.elems.length));
+        for (let elem of array.elems)
+            body.push(...varU32(elem));
+    }
+    return { name: elemId, body };
+}
+
+// For now, the encoding spec is here:
+// https://github.com/WebAssembly/bulk-memory-operations/issues/98#issuecomment-507330729
+
+const LegacyActiveExternVal = 0;
+const PassiveExternVal = 1;
+const ActiveExternVal = 2;
+const DeclaredExternVal = 3;
+const LegacyActiveElemExpr = 4;
+const PassiveElemExpr = 5;
+const ActiveElemExpr = 6;
+const DeclaredElemExpr = 7;
+
+function generalElemSection(elemObjs) {
+    let body = [];
+    body.push(...varU32(elemObjs.length));
+    for (let elemObj of elemObjs) {
+        body.push(elemObj.flag);
+        if ((elemObj.flag & 3) == 2)
+            body.push(...varU32(elemObj.table));
+        // TODO: This is not very flexible
+        if ((elemObj.flag & 1) == 0) {
+            body.push(...varU32(I32ConstCode));
+            body.push(...varS32(elemObj.offset));
+            body.push(...varU32(EndCode));
+        }
+        if (elemObj.flag & 4) {
+            if (elemObj.flag & 3)
+                body.push(elemObj.typeCode & 255);
+            // Each element is an array of bytes
+            body.push(...varU32(elemObj.elems.length));
+            for (let elemBytes of elemObj.elems)
+                body.push(...elemBytes);
+        } else {
+            if (elemObj.flag & 3)
+                body.push(elemObj.externKind & 255);
+            // Each element is a putative function index
+            body.push(...varU32(elemObj.elems.length));
+            for (let elem of elemObj.elems)
+                body.push(...varU32(elem));
+        }
+    }
+    return { name: elemId, body };
+}
+
+function moduleNameSubsection(moduleName) {
+    var body = [];
+    body.push(...varU32(nameTypeModule));
+
+    var subsection = encodedString(moduleName);
+    body.push(...varU32(subsection.length));
+    body.push(...subsection);
+
+    return body;
+}
+
+function funcNameSubsection(funcNames) {
+    var body = [];
+    body.push(...varU32(nameTypeFunction));
+
+    var subsection = varU32(funcNames.length);
+
+    var funcIndex = 0;
+    for (let f of funcNames) {
+        subsection.push(...varU32(f.index ? f.index : funcIndex));
+        subsection.push(...encodedString(f.name, f.nameLen));
+        funcIndex++;
+    }
+
+    body.push(...varU32(subsection.length));
+    body.push(...subsection);
+    return body;
+}
+
+function nameSection(subsections) {
+    var body = [];
+    body.push(...string(nameName));
+
+    for (let ss of subsections)
+        body.push(...ss);
+
+    return { name: userDefinedId, body };
+}
+
+function customSection(name, ...body) {
+    return { name: userDefinedId, body: [...string(name), ...body] };
+}
+
+function tableSection0() {
+    var body = [];
+    body.push(...varU32(0));           // number of tables
+    return { name: tableId, body };
+}
+
+function memorySection0() {
+    var body = [];
+    body.push(...varU32(0));           // number of memories
+    return { name: memoryId, body };
+}
diff --git a/js/src/jit-test/lib/wasm-caching.js b/js/src/jit-test/lib/wasm-caching.js
new file mode 100644
index 0000000000..fc39ab999d
--- /dev/null
+++ b/js/src/jit-test/lib/wasm-caching.js
@@ -0,0 +1,37 @@
+const {Module, Instance, compileStreaming, RuntimeError} = WebAssembly;
+
+function testCached(code, imports, test) {
+    if (typeof code === 'string')
+        code = wasmTextToBinary(code);
+
+    let success = false;
+    let cache = streamCacheEntry(code);
+    assertEq(cache.cached, false);
+    compileStreaming(cache)
+    .then(m => {
+         test(new Instance(m, imports));
+         if (!wasmTestSerializationEnabled()) {
+             assertEq(wasmLoadedFromCache(m), false);
+         }
+         while (!wasmHasTier2CompilationCompleted(m)) {
+            sleep(1);
+         }
+         assertEq(cache.cached, true);
+         return compileStreaming(cache);
+     })
+     .then(m => {
+         test(new Instance(m, imports));
+         assertEq(wasmLoadedFromCache(m), true);
+         assertEq(cache.cached, true);
+
+         let m2 = wasmCompileInSeparateProcess(code);
+         test(new Instance(m2, imports));
+         assertEq(wasmLoadedFromCache(m2), true);
+
+         success = true;
+     })
+     .catch(err => { print(String(err) + " at:\n" + err.stack) });
+
+     drainJobQueue();
+     assertEq(success, true);
+}
diff --git a/js/src/jit-test/lib/wasm.js b/js/src/jit-test/lib/wasm.js
new file mode 100644
index 0000000000..215cf0e421
--- /dev/null
+++ b/js/src/jit-test/lib/wasm.js
@@ -0,0 +1,546 @@
+if (!wasmIsSupported())
+    quit();
+
+load(libdir + "asserts.js");
+
+function canRunHugeMemoryTests() {
+    let conf = getBuildConfiguration();
+    // We're aiming for 64-bit desktop builds with no interesting analysis
+    // running that might inflate memory consumption unreasonably.  It's OK if
+    // they're debug builds, though.
+    //
+    // The build configuration object may be extended at any time with new
+    // properties, so neither an allowlist of properties that can be true or a
+    // blocklist of properties that can't be true is great.  But the latter is
+    // probably better.
+    let blocked = ['rooting-analysis','simulator',
+                   'android','wasi','asan','tsan','ubsan','dtrace','valgrind'];
+    for ( let b of blocked ) {
+        if (conf[b]) {
+            print("Failing canRunHugeMemoryTests() because '" + b + "' is true");
+            return false;
+        }
+    }
+    if (conf['pointer-byte-size'] != 8) {
+        print("Failing canRunHugeMemoryTests() because the build is not 64-bit");
+        return false;
+    }
+    return true;
+}
+
+// On 64-bit systems with explicit bounds checking, ion and baseline can handle
+// 65536 pages.
+
+var PageSizeInBytes = 65536;
+var MaxBytesIn32BitMemory = 0;
+if (largeArrayBufferSupported()) {
+    MaxBytesIn32BitMemory = 65536*PageSizeInBytes;
+} else {
+    // This is an overestimate twice: first, the max byte value is divisible by
+    // the page size; second, it must be a valid bounds checking immediate.  But
+    // INT32_MAX is fine for testing.
+    MaxBytesIn32BitMemory = 0x7FFF_FFFF;
+}
+var MaxPagesIn32BitMemory = Math.floor(MaxBytesIn32BitMemory / PageSizeInBytes);
+
+function wasmEvalText(str, imports) {
+    let binary = wasmTextToBinary(str);
+    let valid = WebAssembly.validate(binary);
+
+    let m;
+    try {
+        m = new WebAssembly.Module(binary);
+        assertEq(valid, true, "failed WebAssembly.validate but still compiled successfully");
+    } catch(e) {
+        if (!e.toString().match(/out of memory/)) {
+            assertEq(valid, false, `passed WebAssembly.validate but failed to compile: ${e}`);
+        }
+        throw e;
+    }
+
+    return new WebAssembly.Instance(m, imports);
+}
+
+function wasmValidateText(str) {
+    let binary = wasmTextToBinary(str);
+    let valid = WebAssembly.validate(binary);
+    if (!valid) {
+        new WebAssembly.Module(binary);
+        throw new Error("module failed WebAssembly.validate but compiled successfully");
+    }
+    assertEq(valid, true, "wasm module was invalid");
+}
+
+function wasmFailValidateText(str, pattern) {
+    let binary = wasmTextToBinary(str);
+    assertEq(WebAssembly.validate(binary), false, "module passed WebAssembly.validate when it should not have");
+    assertErrorMessage(() => new WebAssembly.Module(binary), WebAssembly.CompileError, pattern, "module failed WebAssembly.validate but did not fail to compile as expected");
+}
+
+// Expected compilation failure can happen in a couple of ways:
+//
+// - The compiler can be available but not capable of recognizing some opcodes:
+//   Compilation will start, but will fail with a CompileError.  This is what
+//   happens without --wasm-gc if opcodes enabled by --wasm-gc are used.
+//
+// - The compiler can be unavailable: Compilation will not start at all but will
+//   throw an Error.  This is what happens with "--wasm-gc --wasm-compiler=X" if
+//   X does not support the features enabled by --wasm-gc.
+
+function wasmCompilationShouldFail(bin, compile_error_regex) {
+    try {
+        new WebAssembly.Module(bin);
+    } catch (e) {
+        if (e instanceof WebAssembly.CompileError) {
+            assertEq(compile_error_regex.test(e), true);
+        } else if (e instanceof Error) {
+            assertEq(/can't use wasm debug\/gc without baseline/.test(e), true);
+        } else {
+            throw new Error("Unexpected exception value:\n" + e);
+        }
+    }
+}
+
+function mismatchError(actual, expect) {
+    var str = `(type mismatch: expression has type ${actual} but expected ${expect})|` +
+              `(type mismatch: expected ${expect}, found ${actual}\)`;
+    return RegExp(str);
+}
+
+const emptyStackError = /(from empty stack)|(nothing on stack)/;
+const unusedValuesError = /(unused values not explicitly dropped by end of block)|(values remaining on stack at end of block)/;
+
+function jsify(wasmVal) {
+    if (wasmVal === 'nan')
+        return NaN;
+    if (wasmVal === 'inf')
+        return Infinity;
+    if (wasmVal === '-inf')
+        return Infinity;
+    if (wasmVal === '-0')
+        return -0;
+    return wasmVal;
+}
+
+function _augmentSrc(src, assertions) {
+    let i = 0;
+    let newSrc = src.substr(0, src.lastIndexOf(')'));
+    for (let { func, args, expected, type } of assertions) {
+        newSrc += `
+        (func (export "assert_${i++}") (result i32)
+         ${ args ? args.join('\n') : '' }
+         call ${func}`;
+
+        if (typeof expected !== 'undefined') {
+            switch (type) {
+                case 'f32':
+                    newSrc += `
+         i32.reinterpret/f32
+         ${(function () {
+             if (expected == 'nan:arithmetic') {
+               expected = '0x7FC00000';
+               return '(i32.const 0x7FC00000) i32.and';
+             }
+             return '';
+         })()}
+         i32.const ${expected}
+         i32.eq`;
+                    break;
+                case 'f64':
+                    newSrc += `
+         i64.reinterpret/f64
+         ${(function () {
+             if (expected == 'nan:arithmetic') {
+               expected = '0x7FF8000000000000';
+               return '(i64.const 0x7FF8000000000000) i64.and';
+             }
+             return '';
+         })()}
+         i64.const ${expected}
+         i64.eq`;
+                    break;
+                case 'i32':
+                    newSrc += `
+         i32.const ${expected}
+         i32.eq`;
+                    break;
+                case 'i64':
+                    newSrc += `
+         i64.const ${expected}
+         i64.eq`;
+                    break;
+                case 'v128':
+                    newSrc += `
+         v128.const ${expected}
+         i8x16.eq
+         i8x16.all_true`;
+                    break;
+                default:
+                    throw new Error("unexpected usage of wasmAssert");
+            }
+        } else {
+            // Always true when there's no expected return value.
+            newSrc += "\ni32.const 1";
+        }
+
+        newSrc += ')\n';
+    }
+    newSrc += ')';
+    return newSrc;
+}
+
+function wasmAssert(src, assertions, maybeImports = {}, exportBox = null) {
+    let { exports } = wasmEvalText(_augmentSrc(src, assertions), maybeImports);
+    if (exportBox !== null)
+        exportBox.exports = exports;
+    for (let i = 0; i < assertions.length; i++) {
+        let { func, expected, params } = assertions[i];
+        let paramText = params ? params.join(', ') : '';
+        assertEq(exports[`assert_${i}`](), 1,
+                 `Unexpected value when running ${func}(${paramText}), expecting ${expected}.`);
+    }
+}
+
+// Fully test a module:
+// - ensure it validates.
+// - ensure it compiles and produces the expected result.
+// - ensure textToBinary(binaryToText(binary)) = binary
+// Preconditions:
+// - the binary module must export a function called "run".
+function wasmFullPass(text, expected, maybeImports, ...args) {
+    let binary = wasmTextToBinary(text);
+    assertEq(WebAssembly.validate(binary), true, "Must validate.");
+
+    let module = new WebAssembly.Module(binary);
+    let instance = new WebAssembly.Instance(module, maybeImports);
+    assertEq(typeof instance.exports.run, 'function', "A 'run' function must be exported.");
+    assertEq(instance.exports.run(...args), expected, "Initial module must return the expected result.");
+}
+
+// Ditto, but expects a function named '$run' instead of exported with this name.
+function wasmFullPassI64(text, expected, maybeImports, ...args) {
+    let binary = wasmTextToBinary(text);
+    assertEq(WebAssembly.validate(binary), true, "Must validate.");
+
+    let augmentedSrc = _augmentSrc(text, [ { type: 'i64', func: '$run', args, expected } ]);
+    let augmentedBinary = wasmTextToBinary(augmentedSrc);
+
+    let module = new WebAssembly.Module(augmentedBinary);
+    let instance = new WebAssembly.Instance(module, maybeImports);
+    assertEq(instance.exports.assert_0(), 1);
+}
+
+function wasmRunWithDebugger(wast, lib, init, done) {
+    let g = newGlobal({newCompartment: true});
+    let dbg = new Debugger(g);
+
+    g.eval(`
+var wasm = wasmTextToBinary(\`${wast}\`);
+var lib = ${lib || 'undefined'};
+var m = new WebAssembly.Instance(new WebAssembly.Module(wasm), lib);`);
+
+    var wasmScript = dbg.findScripts().filter(s => s.format == 'wasm')[0];
+
+    init({dbg, wasmScript, g,});
+    let result = undefined, error = undefined;
+    try {
+        result = g.eval("m.exports.test()");
+    } catch (ex) {
+        error = ex;
+    }
+    done({dbg, result, error, wasmScript, g,});
+}
+
+const WasmHelpers = {};
+
+(function() {
+    let enabled = false;
+    try {
+        enableSingleStepProfiling();
+        disableSingleStepProfiling();
+        enabled = true;
+    } catch (e) {}
+    WasmHelpers.isSingleStepProfilingEnabled = enabled;
+})();
+
+// The cache of matched and unmatched strings seriously speeds up matching on
+// the emulators and makes tests time out less often.
+
+var matched = {};
+var unmatched = {};
+
+WasmHelpers._normalizeStack = (stack, preciseStacks) => {
+    var wasmFrameTypes = [
+        {re:/^jit call to int64(?: or v128)? wasm function$/,             sub:"i64>"},
+        {re:/^out-of-line coercion for jit entry arguments \(in wasm\)$/, sub:"ool>"},
+        {re:/^wasm-function\[(\d+)\] \(.*\)$/,                            sub:"$1"},
+        {re:/^(fast|slow) exit trampoline (?:to native )?\(in wasm\)$/,   sub:"<"},
+        {re:/^call to(?: asm.js)? native (.*) \(in wasm\)$/,              sub:"$1"},
+        {re:/ \(in wasm\)$/,                                              sub:""}
+    ];
+
+    let entryRegexps;
+    if (preciseStacks) {
+        entryRegexps = [
+            {re:/^slow entry trampoline \(in wasm\)$/,                    sub:"!>"},
+            {re:/^fast entry trampoline \(in wasm\)$/,                    sub:">"},
+        ];
+    } else {
+        entryRegexps = [
+            {re:/^(fast|slow) entry trampoline \(in wasm\)$/,             sub:">"}
+        ];
+    }
+    wasmFrameTypes = entryRegexps.concat(wasmFrameTypes);
+
+    var framesIn = stack.split(',');
+    var framesOut = [];
+  outer:
+    for (let frame of framesIn) {
+        if (unmatched[frame])
+            continue;
+        let probe = matched[frame];
+        if (probe !== undefined) {
+            framesOut.push(probe);
+            continue;
+        }
+        for (let {re, sub} of wasmFrameTypes) {
+            if (re.test(frame)) {
+                let repr = frame.replace(re, sub);
+                framesOut.push(repr);
+                matched[frame] = repr;
+                continue outer;
+            }
+        }
+        unmatched[frame] = true;
+    }
+
+    return framesOut.join(',');
+};
+
+WasmHelpers._removeAdjacentDuplicates = array => {
+    if (array.length < 2)
+        return;
+    let i = 0;
+    for (let j = 1; j < array.length; j++) {
+        if (array[i] !== array[j])
+            array[++i] = array[j];
+    }
+    array.length = i + 1;
+}
+
+WasmHelpers.normalizeStacks = (stacks, preciseStacks = false) => {
+    let observed = [];
+    for (let i = 0; i < stacks.length; i++)
+        observed[i] = WasmHelpers._normalizeStack(stacks[i], preciseStacks);
+    WasmHelpers._removeAdjacentDuplicates(observed);
+    return observed;
+};
+
+WasmHelpers._compareStacks = (got, expect) => {
+    if (got.length != expect.length) {
+        return false;
+    }
+    for (let i = 0; i < got.length; i++) {
+        if (got[i] !== expect[i])
+            return false;
+    }
+    return true;
+}
+
+WasmHelpers.assertEqImpreciseStacks = (got, expect) => {
+    let observed = WasmHelpers.normalizeStacks(got, /* precise */ false);
+    let same = WasmHelpers._compareStacks(observed, expect);
+    if (!same) {
+        if (observed.length != expect.length) {
+            print(`Got:\n${observed.toSource()}\nExpect:\n${expect.toSource()}`);
+            assertEq(observed.length, expect.length);
+        }
+        for (let i = 0; i < observed.length; i++) {
+            if (observed[i] !== expect[i]) {
+                print(`On stack ${i}, Got:\n${observed[i]}\nExpect:\n${expect[i]}`);
+                assertEq(observed[i], expect[i]);
+            }
+        }
+    }
+}
+
+WasmHelpers.extractStackFrameFunction = (frameString) => {
+    var [_, name, filename, line, column] = frameString.match(/^(.*)@(.*):(.*):(.*)$/);
+    if (name)
+        return name;
+    if (/wasm-function/.test(line))
+        return line;
+    return "";
+};
+
+WasmHelpers.assertStackTrace = (exception, expected) => {
+    let callsites = exception.stack.trim().split('\n').map(WasmHelpers.extractStackFrameFunction);
+    assertEq(callsites.length, expected.length);
+    for (let i = 0; i < callsites.length; i++) {
+        assertEq(callsites[i], expected[i]);
+    }
+};
+
+WasmHelpers.nextLineNumber = (n=1) => {
+    return +(new Error().stack).split('\n')[1].split(':')[1] + n;
+}
+
+WasmHelpers.startProfiling = () => {
+    if (!WasmHelpers.isSingleStepProfilingEnabled)
+        return;
+    enableSingleStepProfiling();
+}
+
+WasmHelpers.endProfiling = () => {
+    if (!WasmHelpers.isSingleStepProfilingEnabled)
+        return;
+    return disableSingleStepProfiling();
+}
+
+WasmHelpers.assertEqPreciseStacks = (observed, expectedStacks) => {
+    if (!WasmHelpers.isSingleStepProfilingEnabled)
+        return null;
+
+    observed = WasmHelpers.normalizeStacks(observed, /* precise */ true);
+
+    for (let i = 0; i < expectedStacks.length; i++) {
+        if (WasmHelpers._compareStacks(observed, expectedStacks[i]))
+            return i;
+    }
+
+    throw new Error(`no plausible stacks found, observed: ${observed.join('/')}
+Expected one of:
+${expectedStacks.map(stacks => stacks.join("/")).join('\n')}`);
+}
+
+function fuzzingSafe() {
+    return typeof getErrorNotes == 'undefined';
+}
+
+// Common instantiations of wasm values for dynamic type check testing
+
+// Valid values for funcref
+let WasmFuncrefValues = [
+    wasmEvalText(`(module (func (export "")))`).exports[''],
+];
+
+// Valid values for structref/arrayref
+let WasmStructrefValues = [];
+let WasmArrayrefValues = [];
+if (wasmGcEnabled()) {
+    let { newStruct, newArray } = wasmEvalText(`
+      (module
+        (type $s (struct))
+        (type $a (array i32))
+        (func (export "newStruct") (result anyref)
+            struct.new $s)
+        (func (export "newArray") (result anyref)
+            i32.const 0
+            i32.const 0
+            array.new $a)
+      )`).exports;
+    WasmStructrefValues.push(newStruct());
+    WasmArrayrefValues.push(newArray());
+}
+
+// Valid values for eqref
+let WasmEqrefValues = [...WasmStructrefValues, ...WasmArrayrefValues];
+
+// Valid and invalid values for anyref
+let WasmAnyrefValues = [...WasmEqrefValues];
+let WasmNonAnyrefValues = [
+    undefined,
+    true,
+    false,
+    {x:1337},
+    ["abracadabra"],
+    1337,
+    13.37,
+    "hi",
+    37n,
+    new Number(42),
+    new Boolean(true),
+    Symbol("status"),
+    () => 1337,
+    ...WasmFuncrefValues,
+];
+
+// Valid externref values
+let WasmNonNullExternrefValues = [
+    ...WasmNonAnyrefValues,
+    ...WasmAnyrefValues
+];
+let WasmExternrefValues = [null, ...WasmNonNullExternrefValues];
+
+// Common array utilities
+
+// iota(n) creates an Array of length n with values 0..n-1
+function iota(len) {
+    let xs = [];
+    for ( let i=0 ; i < len ; i++ )
+        xs.push(i);
+    return xs;
+}
+
+// cross(A) where A is an array of length n creates an Array length n*n of
+// two-element Arrays representing all pairs of elements of A.
+function cross(xs) {
+    let results = [];
+    for ( let x of xs )
+        for ( let y of xs )
+            results.push([x,y]);
+    return results;
+}
+
+// Remove all values equal to v from an array xs, comparing equal for NaN.
+function remove(v, xs) {
+    let result = [];
+    for ( let w of xs ) {
+        if (v === w || isNaN(v) && isNaN(w))
+            continue;
+        result.push(w);
+    }
+    return result;
+}
+
+// permute(A) where A is an Array returns an Array of Arrays, each inner Array a
+// distinct permutation of the elements of A.  A is assumed not to have any
+// elements that are pairwise equal in the sense of remove().
+function permute(xs) {
+    if (xs.length == 1)
+        return [xs];
+    let results = [];
+    for (let v of xs)
+        for (let tail of permute(remove(v, xs)))
+            results.push([v, ...tail]);
+    return results;
+}
+
+// interleave([a,b,c,...],[0,1,2,...]) => [a,0,b,1,c,2,...]
+function interleave(xs, ys) {
+    assertEq(xs.length, ys.length);
+    let res = [];
+    for ( let i=0 ; i < xs.length; i++ ) {
+        res.push(xs[i]);
+        res.push(ys[i]);
+    }
+    return res;
+}
+
+// assertSame([a,...],[b,...]) asserts that the two arrays have the same length
+// and that they element-wise assertEq IGNORING Number/BigInt differences.  This
+// predicate is in this file because it is wasm-specific.
+function assertSame(got, expected) {
+    assertEq(got.length, expected.length);
+    for ( let i=0; i < got.length; i++ ) {
+        let g = got[i];
+        let e = expected[i];
+        if (typeof g != typeof e) {
+            if (typeof g == "bigint")
+                e = BigInt(e);
+            else if (typeof e == "bigint")
+                g = BigInt(g);
+        }
+        assertEq(g, e);
+    }
+}
diff --git a/js/src/jit-test/manual-tests/dense-to-sparse.js b/js/src/jit-test/manual-tests/dense-to-sparse.js
new file mode 100644
index 0000000000..efe56620da
--- /dev/null
+++ b/js/src/jit-test/manual-tests/dense-to-sparse.js
@@ -0,0 +1,40 @@
+// |jit-test| allow-oom
+// Appending elements to a dense array should make the array sparse when the
+// length exceeds the limit.
+
+function test() {
+  const MAX_DENSE_ELEMENTS_ALLOCATION = (1 << 28) - 1;
+  const VALUES_PER_HEADER = 2;
+  const MAX_DENSE_ELEMENTS_COUNT = MAX_DENSE_ELEMENTS_ALLOCATION - VALUES_PER_HEADER;
+  const SPARSE_DENSITY_RATIO = 8;
+  const MIN_DENSE = MAX_DENSE_ELEMENTS_COUNT / SPARSE_DENSITY_RATIO;
+  const MARGIN = 16;
+
+  let a = [];
+  // Fill the beginning of array to make it keep dense until length exceeds
+  // MAX_DENSE_ELEMENTS_COUNT.
+  for (let i = 0; i < MIN_DENSE; i++)
+    a[i] = i;
+
+  // Skip from MIN_DENSE to MAX_DENSE_ELEMENTS_COUNT - MARGIN, to reduce the
+  // time taken by test.
+
+  // Fill the ending of array to make it sparse at MAX_DENSE_ELEMENTS_COUNT.
+  for (let i = MAX_DENSE_ELEMENTS_COUNT - MARGIN; i < MAX_DENSE_ELEMENTS_COUNT + MARGIN; i++)
+    a[i] = i;
+
+  // Make sure the last element is defined.
+  assertEq(a.length, MAX_DENSE_ELEMENTS_COUNT + MARGIN);
+  assertEq(a[a.length - 1], MAX_DENSE_ELEMENTS_COUNT + MARGIN - 1);
+
+  // Make sure elements around MAX_DENSE_ELEMENTS_COUNT are also defined.
+  assertEq(a[MAX_DENSE_ELEMENTS_COUNT - 1], MAX_DENSE_ELEMENTS_COUNT - 1);
+  assertEq(a[MAX_DENSE_ELEMENTS_COUNT], MAX_DENSE_ELEMENTS_COUNT);
+  assertEq(a[MAX_DENSE_ELEMENTS_COUNT + 1], MAX_DENSE_ELEMENTS_COUNT + 1);
+}
+
+var config = getBuildConfiguration();
+// Takes too long time on debug build.
+if (!config.debug) {
+  test();
+}
diff --git a/js/src/jit-test/modules/ambiguous.js b/js/src/jit-test/modules/ambiguous.js
new file mode 100644
index 0000000000..3e0d31e3ed
--- /dev/null
+++ b/js/src/jit-test/modules/ambiguous.js
@@ -0,0 +1,2 @@
+export * from 'module1.js';
+export * from 'module1a.js';
diff --git a/js/src/jit-test/modules/cyclicImport1.js b/js/src/jit-test/modules/cyclicImport1.js
new file mode 100644
index 0000000000..d64803a005
--- /dev/null
+++ b/js/src/jit-test/modules/cyclicImport1.js
@@ -0,0 +1,4 @@
+import { b } from "cyclicImport2.js";
+
+export let a = 1;
+assertEq(b, 2);
diff --git a/js/src/jit-test/modules/cyclicImport2.js b/js/src/jit-test/modules/cyclicImport2.js
new file mode 100644
index 0000000000..e7c3cd924e
--- /dev/null
+++ b/js/src/jit-test/modules/cyclicImport2.js
@@ -0,0 +1,4 @@
+import { a } from "cyclicImport1.js";
+
+export let b = 2;
+assertEq(a, 1);
diff --git a/js/src/jit-test/modules/defaultClass.js b/js/src/jit-test/modules/defaultClass.js
new file mode 100644
index 0000000000..c05d5ff5a0
--- /dev/null
+++ b/js/src/jit-test/modules/defaultClass.js
@@ -0,0 +1,5 @@
+export default class {
+    triple(x) {
+        return x * 3;
+    }
+}
diff --git a/js/src/jit-test/modules/defaultFunction.js b/js/src/jit-test/modules/defaultFunction.js
new file mode 100644
index 0000000000..1c6e75d453
--- /dev/null
+++ b/js/src/jit-test/modules/defaultFunction.js
@@ -0,0 +1,3 @@
+export default function(x) {
+    return x * 2;
+}
diff --git a/js/src/jit-test/modules/empty.js b/js/src/jit-test/modules/empty.js
new file mode 100644
index 0000000000..bd9ec079d8
--- /dev/null
+++ b/js/src/jit-test/modules/empty.js
@@ -0,0 +1 @@
+// Intentionally empty.
diff --git a/js/src/jit-test/modules/export-circular-nonexisting-binding-1.js b/js/src/jit-test/modules/export-circular-nonexisting-binding-1.js
new file mode 100644
index 0000000000..2b91b6a284
--- /dev/null
+++ b/js/src/jit-test/modules/export-circular-nonexisting-binding-1.js
@@ -0,0 +1,4 @@
+import "export-circular-nonexisting-binding-2.js";
+
+export* from "empty.js";
+export {x} from "empty.js";
diff --git a/js/src/jit-test/modules/export-circular-nonexisting-binding-2.js b/js/src/jit-test/modules/export-circular-nonexisting-binding-2.js
new file mode 100644
index 0000000000..ba7dcc1b48
--- /dev/null
+++ b/js/src/jit-test/modules/export-circular-nonexisting-binding-2.js
@@ -0,0 +1 @@
+export {x} from "export-circular-nonexisting-binding-1.js";
diff --git a/js/src/jit-test/modules/export-default-async-asi.js b/js/src/jit-test/modules/export-default-async-asi.js
new file mode 100644
index 0000000000..a69a7aa3dc
--- /dev/null
+++ b/js/src/jit-test/modules/export-default-async-asi.js
@@ -0,0 +1,2 @@
+export default async // ASI occurs here due to the [no LineTerminator here] restriction on default-exporting an async function
+function async() { return 17; }
diff --git a/js/src/jit-test/modules/export-default-async-regexpy.js b/js/src/jit-test/modules/export-default-async-regexpy.js
new file mode 100644
index 0000000000..3a33ecbc85
--- /dev/null
+++ b/js/src/jit-test/modules/export-default-async-regexpy.js
@@ -0,0 +1,6 @@
+var async = 42;
+var x = 3;
+var g = 2;
+
+export default async
+/x/g;
diff --git a/js/src/jit-test/modules/export-ns.js b/js/src/jit-test/modules/export-ns.js
new file mode 100644
index 0000000000..0d2e499088
--- /dev/null
+++ b/js/src/jit-test/modules/export-ns.js
@@ -0,0 +1 @@
+export * as ns from "module1.js";
diff --git a/js/src/jit-test/modules/export-star-circular-1.js b/js/src/jit-test/modules/export-star-circular-1.js
new file mode 100644
index 0000000000..9a0771b024
--- /dev/null
+++ b/js/src/jit-test/modules/export-star-circular-1.js
@@ -0,0 +1 @@
+export* from "export-star-circular-2.js";
diff --git a/js/src/jit-test/modules/export-star-circular-2.js b/js/src/jit-test/modules/export-star-circular-2.js
new file mode 100644
index 0000000000..b273d9cefa
--- /dev/null
+++ b/js/src/jit-test/modules/export-star-circular-2.js
@@ -0,0 +1,3 @@
+export {y as x} from "export-star-circular-1.js";
+
+export var y = "pass";
diff --git a/js/src/jit-test/modules/exportImportMeta.js b/js/src/jit-test/modules/exportImportMeta.js
new file mode 100644
index 0000000000..28937ade4e
--- /dev/null
+++ b/js/src/jit-test/modules/exportImportMeta.js
@@ -0,0 +1,3 @@
+export default function() {
+    return import.meta;
+}
diff --git a/js/src/jit-test/modules/isEven.js b/js/src/jit-test/modules/isEven.js
new file mode 100644
index 0000000000..242cddf402
--- /dev/null
+++ b/js/src/jit-test/modules/isEven.js
@@ -0,0 +1,12 @@
+import { isOdd } from "isOdd.js"
+
+export function isEven(x) {
+    if (x < 0)
+        throw "negative";
+    if (x == 0)
+        return true;
+    return isOdd(x - 1);
+}
+
+assertEq(isEven(4), true);
+assertEq(isOdd(5), true);
diff --git a/js/src/jit-test/modules/isOdd.js b/js/src/jit-test/modules/isOdd.js
new file mode 100644
index 0000000000..2cada0cf93
--- /dev/null
+++ b/js/src/jit-test/modules/isOdd.js
@@ -0,0 +1,12 @@
+import { isEven } from "isEven.js"
+
+export function isOdd(x) {
+    if (x < 0)
+        throw "negative";
+    if (x == 0)
+        return false;
+    return isEven(x - 1);
+}
+
+assertEq(isEven(4), true);
+assertEq(isOdd(5), true);
diff --git a/js/src/jit-test/modules/module1.js b/js/src/jit-test/modules/module1.js
new file mode 100644
index 0000000000..cc798ff50d
--- /dev/null
+++ b/js/src/jit-test/modules/module1.js
@@ -0,0 +1 @@
+export const a = 1;
diff --git a/js/src/jit-test/modules/module1a.js b/js/src/jit-test/modules/module1a.js
new file mode 100644
index 0000000000..66d48fc1e6
--- /dev/null
+++ b/js/src/jit-test/modules/module1a.js
@@ -0,0 +1 @@
+export const a = 2;
diff --git a/js/src/jit-test/modules/module2.js b/js/src/jit-test/modules/module2.js
new file mode 100644
index 0000000000..6287b0f71c
--- /dev/null
+++ b/js/src/jit-test/modules/module2.js
@@ -0,0 +1 @@
+export let b = 2;
diff --git a/js/src/jit-test/modules/module3.js b/js/src/jit-test/modules/module3.js
new file mode 100644
index 0000000000..df4cdade58
--- /dev/null
+++ b/js/src/jit-test/modules/module3.js
@@ -0,0 +1 @@
+export var c = 3;
diff --git a/js/src/jit-test/modules/module4.js b/js/src/jit-test/modules/module4.js
new file mode 100644
index 0000000000..456ffaafac
--- /dev/null
+++ b/js/src/jit-test/modules/module4.js
@@ -0,0 +1 @@
+export default 4;
diff --git a/js/src/jit-test/modules/recursiveStarExport.js b/js/src/jit-test/modules/recursiveStarExport.js
new file mode 100644
index 0000000000..681c7be91b
--- /dev/null
+++ b/js/src/jit-test/modules/recursiveStarExport.js
@@ -0,0 +1 @@
+export * from 'recursiveStarExport.js';