diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index c3513897b1b..642034e0691 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -18,7 +18,8 @@ jobs:
   lint:
     name: lint
     if: ${{ github.event_name == 'pull_request' }}
-    runs-on: ubuntu-latest
+    # Use Ubuntu 26.04 to get clang-21 (not present in 24.04)
+    runs-on: ubuntu-26.04
     env:
       # Keep this in sync with clang-format-diff.sh
       LLVM_VERSION: 21
@@ -34,10 +35,7 @@ jobs:
       run: |
         pip3 install -r requirements-dev.txt
         sudo apt install lsb-release wget software-properties-common gnupg
-        wget https://apt.llvm.org/llvm.sh
-        sudo chmod +x llvm.sh
-        sudo ./llvm.sh ${LLVM_VERSION}
-        sudo apt-get install clang-format clang-format-${LLVM_VERSION} clang-tidy-${LLVM_VERSION}
+        sudo apt-get install clang-${LLVM_VERSION} clang-format-${LLVM_VERSION} clang-tidy-${LLVM_VERSION}
     - run: ruff check
     - run: ./scripts/clang-format-diff.sh
     - name: clang-tidy
@@ -199,11 +197,6 @@ jobs:
     - uses: actions/checkout@v4
       with:
         submodules: true
-    - name: install clang 18
-      run: |
-        wget https://apt.llvm.org/llvm.sh
-        chmod +x llvm.sh
-        sudo ./llvm.sh 18
     - name: install ninja
       run: sudo apt-get install ninja-build
     - name: install v8
@@ -322,11 +315,6 @@ jobs:
     - uses: actions/checkout@v4
       with:
         submodules: true
-    - name: install clang 18
-      run: |
-        wget https://apt.llvm.org/llvm.sh
-        chmod +x llvm.sh
-        sudo ./llvm.sh 18
     - name: install ninja
       run: sudo apt-get install ninja-build
     - name: install v8
diff --git a/CHANGELOG.md b/CHANGELOG.md
index e26794db203..3015ac5125a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -20,6 +20,9 @@ Current Trunk
 - Replace the `BINARYEN_ROOT` environment variable (used by developers who are
   doing out-of-tree builds of binaryen) with `BINARYEN_BIN` (#9023)
 - Reject non-natural alignment for atomic memory operations at parse time (#8962)
+- Note that fast-math mode can ignore the difference between negative zero and
+  zero (like clang and gcc). (#9056)
+- [JS API] **(breaking)** Organize types into enums (#9098)
 
 v132
 ----
diff --git a/check.py b/check.py
index 3d1ca8aef46..b71f74e3888 100755
--- a/check.py
+++ b/check.py
@@ -16,13 +16,10 @@
 
 import functools
 import glob
-import io
 import os
 import subprocess
 import sys
 import unittest
-from contextlib import contextmanager
-from multiprocessing.pool import ThreadPool
 from pathlib import Path
 
 from scripts.test import binaryenjs, finalize, shared, support, wasm2js, wasm_opt
@@ -140,6 +137,32 @@ def run_wasm_metadce_tests():
         shared.fail_if_not_identical_to_file(stdout, expected + '.stdout')
 
 
+def run_one_wasm_reduce_test(t, stdout=None):
+    base_name = os.path.splitext(os.path.basename(t))[0]
+    print('..', os.path.basename(t), file=stdout)
+    a_wasm = f'reduce_{base_name}_a.wasm'
+    b_wasm = f'reduce_{base_name}_b.wasm'
+    c_wasm = f'reduce_{base_name}_c.wasm'
+    a_wat = f'reduce_{base_name}_a.wat'
+    try:
+        support.run_command(shared.WASM_AS + [t, '-o', a_wasm, '-all'], stdout=stdout)
+        cmd = shared.WASM_OPT[0]
+        support.run_command(
+            shared.WASM_REDUCE + [a_wasm, f'--command={cmd} {b_wasm} --fuzz-exec -all', '-t', b_wasm, '-w', c_wasm, '--timeout=4'],
+            stdout=stdout,
+            stderr=subprocess.PIPE,
+        )
+        expected = t + '.txt'
+        support.run_command(shared.WASM_DIS + [c_wasm, '-o', a_wat], stdout=stdout)
+        with open(a_wat) as seen:
+            shared.fail_if_not_identical_to_file(seen.read(), expected)
+    finally:
+        shared.delete_from_orbit(a_wasm)
+        shared.delete_from_orbit(b_wasm)
+        shared.delete_from_orbit(c_wasm)
+        shared.delete_from_orbit(a_wat)
+
+
 def run_wasm_reduce_tests():
     if not shared.has_shell_timeout():
         print_heading('skipping wasm-reduce testcases')
@@ -148,16 +171,8 @@ def run_wasm_reduce_tests():
     print_heading('checking wasm-reduce testcases')
 
     # fixed testcases
-    for t in shared.get_tests(shared.get_test_dir('reduce'), ['.wast']):
-        print('..', os.path.basename(t))
-        # convert to wasm
-        support.run_command(shared.WASM_AS + [t, '-o', 'a.wasm', '-all'])
-        cmd = shared.WASM_OPT[0]
-        support.run_command(shared.WASM_REDUCE + ['a.wasm', f'--command={cmd} b.wasm --fuzz-exec -all ', '-t', 'b.wasm', '-w', 'c.wasm', '--timeout=4'])
-        expected = t + '.txt'
-        support.run_command(shared.WASM_DIS + ['c.wasm', '-o', 'a.wat'])
-        with open('a.wat') as seen:
-            shared.fail_if_not_identical_to_file(seen.read(), expected)
+    tests = shared.get_tests(shared.get_test_dir('reduce'), ['.wast'])
+    shared.run_parallel_tests(run_one_wasm_reduce_test, tests)
 
     # run on a nontrivial fuzz testcase, for general coverage
     # this is very slow in ThreadSanitizer, so avoid it there
@@ -232,7 +247,6 @@ def run_one_spec_test(wast: Path, stdout=None):
             shared.verbose_log('<< test failed as expected >>', file=stdout)
             return  # don't try all the binary format stuff TODO
         else:
-            shared.fail_with_error(str(e))
             raise
 
     check_expected(actual, expected, stdout=stdout)
@@ -265,67 +279,10 @@ def run_one_spec_test(wast: Path, stdout=None):
     check_expected(actual, os.path.join(shared.get_test_dir('spec'), 'expected-output', test_name + '.log'), stdout=stdout)
 
 
-def run_spec_test_with_wrapped_stdout(wast: Path):
-    """Run a single spec test while capturing stdout.
-
-    Return (bool, str) where the first element is whether the test was
-    successful and the second is the combined stdout and stderr of the test.
-    """
-    out = io.StringIO()
-    try:
-        run_one_spec_test(wast, stdout=out)
-    except Exception as e:
-        shared.num_failures += 1
-        # Serialize exceptions into the output string buffer
-        # so they can be reported on the main thread.
-        print(e, file=out)
-        return False, out.getvalue()
-    return True, out.getvalue()
-
-
-@contextmanager
-def red_output(file=sys.stdout):
-    print("\033[31m", end="", file=file)
-    try:
-        yield
-    finally:
-        print("\033[0m", end="", file=file)
-
-
-def red_stderr():
-    return red_output(file=sys.stderr)
-
-
 def run_spec_tests():
     print_heading('checking wasm-shell spec testcases...')
-
-    worker_count = os.cpu_count()
-    print("Running with", worker_count, "workers")
     test_paths = (Path(x) for x in shared.options.spec_tests)
-
-    failed_stdouts = []
-    with ThreadPool(processes=worker_count) as pool:
-        try:
-            for success, stdout in pool.imap_unordered(run_spec_test_with_wrapped_stdout, test_paths):
-                if success:
-                    print(stdout, end="")
-                    continue
-
-                failed_stdouts.append(stdout)
-                if shared.options.abort_on_first_failure:
-                    with red_stderr():
-                        print("Aborted spec test suite execution after first failure. Set --no-fail-fast to disable this.", file=sys.stderr)
-                    break
-        except KeyboardInterrupt:
-            # Hard exit to avoid threads continuing to run after Ctrl-C.
-            # There's no concern of deadlocking during shutdown here.
-            os._exit(1)
-
-    if failed_stdouts:
-        with red_stderr():
-            print("Failed tests:", file=sys.stderr)
-            for failed in failed_stdouts:
-                print(failed, end="", file=sys.stderr)
+    shared.run_parallel_tests(run_one_spec_test, test_paths)
 
 
 def run_validator_tests():
@@ -345,6 +302,44 @@ def run_validator_tests():
     support.run_command(cmd, expected_status=1)
 
 
+def run_one_example_test(t, stdout=None):
+    src = os.path.join(shared.get_test_dir('example'), t)
+    expected = os.path.join(shared.get_test_dir('example'), '.'.join(t.split('.')[:-1]) + '.txt')
+    # build the C file separately
+    libpath = shared.options.binaryen_lib
+    output_file = os.path.basename(os.path.splitext(t)[0])
+    objfile = output_file + '.o'
+    compile = [shared.NATIVECC, src, '-c', '-o', objfile,
+             '-I' + os.path.join(shared.options.binaryen_root, 'src'), '-g', '-L' + libpath, '-pthread']
+    if src.endswith('.cpp'):
+        compile += ['-std=c++' + str(shared.cxx_standard)]
+    if os.environ.get('COMPILER_FLAGS'):
+        for f in os.environ.get('COMPILER_FLAGS').split(' '):
+            compile.append(f)
+    print('build: ', ' '.join(compile), file=stdout)
+    proc = subprocess.run(compile, capture_output=True, text=True)
+    if proc.returncode != 0:
+        raise Exception(f"Failed to compile {src}:\n{proc.stderr or proc.stdout}")
+
+    cmd = ['-I' + os.path.join(shared.options.binaryen_root, 't'), '-g', '-pthread', '-o', output_file]
+    # Link against the binaryen C library DSO, using an executable-relative rpath
+    cmd = [objfile, '-L' + libpath, '-lbinaryen'] + cmd + ['-Wl,-rpath,' + libpath]
+    print('  ', t, src, expected, file=stdout)
+    if os.environ.get('COMPILER_FLAGS'):
+        for f in os.environ.get('COMPILER_FLAGS').split(' '):
+            cmd.append(f)
+    cmd = [shared.NATIVEXX, '-std=c++' + str(shared.cxx_standard)] + cmd
+    print('link: ', ' '.join(cmd), file=stdout)
+    proc = subprocess.run(cmd, capture_output=True, text=True)
+    if proc.returncode != 0:
+        raise Exception(f"Failed to link {output_file}:\n{proc.stderr or proc.stdout}")
+    print('run...', output_file, file=stdout)
+    proc = subprocess.run([os.path.abspath(output_file)], capture_output=True, text=True)
+    if proc.returncode != 0:
+        raise Exception(f"Failed to run {output_file}:\n{proc.stderr or proc.stdout}")
+    shared.fail_if_not_identical_to_file(proc.stdout, expected)
+
+
 def run_example_tests():
     print_heading('checking native example testcases...')
     if not shared.NATIVECC or not shared.NATIVEXX:
@@ -354,38 +349,8 @@ def run_example_tests():
     if shared.skip_if_on_windows('example'):
         return
 
-    for t in shared.get_tests(shared.get_test_dir('example')):
-        if not t.endswith(('.c', '.cpp')):
-            continue
-        src = os.path.join(shared.get_test_dir('example'), t)
-        expected = os.path.join(shared.get_test_dir('example'), '.'.join(t.split('.')[:-1]) + '.txt')
-        # build the C file separately
-        libpath = shared.options.binaryen_lib
-        output_file = os.path.basename(os.path.splitext(t)[0])
-        objfile = output_file + '.o'
-        compile = [shared.NATIVECC, src, '-c', '-o', objfile,
-                 '-I' + os.path.join(shared.options.binaryen_root, 'src'), '-g', '-L' + libpath, '-pthread']
-        if src.endswith('.cpp'):
-            compile += ['-std=c++' + str(shared.cxx_standard)]
-        if os.environ.get('COMPILER_FLAGS'):
-            for f in os.environ.get('COMPILER_FLAGS').split(' '):
-                compile.append(f)
-        print('build: ', ' '.join(compile))
-        subprocess.check_call(compile)
-
-        cmd = ['-I' + os.path.join(shared.options.binaryen_root, 't'), '-g', '-pthread', '-o', output_file]
-        # Link against the binaryen C library DSO, using an executable-relative rpath
-        cmd = [objfile, '-L' + libpath, '-lbinaryen'] + cmd + ['-Wl,-rpath,' + libpath]
-        print('  ', t, src, expected)
-        if os.environ.get('COMPILER_FLAGS'):
-            for f in os.environ.get('COMPILER_FLAGS').split(' '):
-                cmd.append(f)
-        cmd = [shared.NATIVEXX, '-std=c++' + str(shared.cxx_standard)] + cmd
-        print('link: ', ' '.join(cmd))
-        subprocess.check_call(cmd)
-        print('run...', output_file)
-        actual = subprocess.check_output([os.path.abspath(output_file)], text=True)
-        shared.fail_if_not_identical_to_file(actual, expected)
+    tests = shared.get_tests(shared.get_test_dir('example'), ['.c', '.cpp'])
+    shared.run_parallel_tests(run_one_example_test, tests)
 
 
 def run_unittest():
diff --git a/requirements-dev.txt b/requirements-dev.txt
index 500c11b34e0..d33bb82c75d 100644
--- a/requirements-dev.txt
+++ b/requirements-dev.txt
@@ -4,5 +4,5 @@
 # Install with `pip3 install -r requirements-dev.txt`
 
 ruff==0.16.0
-filecheck==0.0.22
+filecheck==1.0.5
 lit==0.11.0.post1
diff --git a/scripts/bundle_clusterfuzz.py b/scripts/bundle_clusterfuzz.py
index 941384cfc40..96940af3c47 100755
--- a/scripts/bundle_clusterfuzz.py
+++ b/scripts/bundle_clusterfuzz.py
@@ -115,7 +115,8 @@
     '--disable-relaxed-atomics',
 ]
 
-with tarfile.open(output_file, "w:gz") as tar:
+# Use fast compression (level 1) to speed up bundling with only a modest size increase.
+with tarfile.open(output_file, 'w:gz', compresslevel=1) as tar:
     # run.py
     run = os.path.join(shared.options.binaryen_root, 'scripts', 'clusterfuzz', 'run.py')
     print(f'  .. run:         {run}')
diff --git a/scripts/fuzz_opt.py b/scripts/fuzz_opt.py
index 77652a53971..67b00e7b94d 100755
--- a/scripts/fuzz_opt.py
+++ b/scripts/fuzz_opt.py
@@ -272,12 +272,12 @@ def auto_select_recent_initial_contents():
         # commit time of HEAD. The reason we use the commit time of HEAD instead
         # of the current system time is to make the results deterministic given
         # the Binaryen HEAD commit.
-        head_ts_str = run(['git', 'log', '-1', '--format=%cd', '--date=raw'],
+        head_ts_str = run(['git', '-C', shared.options.binaryen_root, 'log', '-1', '--format=%cd', '--date=raw'],
                           silent=True).split()[0]
         head_dt = datetime.utcfromtimestamp(int(head_ts_str))
         start_dt = head_dt - timedelta(days=RECENT_DAYS)
         start_ts = start_dt.replace(tzinfo=timezone.utc).timestamp()
-        log = run(['git', 'log', '--name-status', '--format=', '--date=raw', '--no-renames', f'--since={start_ts}'], silent=True).splitlines()
+        log = run(['git', '-C', shared.options.binaryen_root, 'log', '--name-status', '--format=', '--date=raw', '--no-renames', f'--since={start_ts}'], silent=True).splitlines()
         # Pick up lines in the form of
         # A       test/../something.wast
         # M       test/../something.wast
@@ -290,7 +290,7 @@ def auto_select_recent_initial_contents():
 
     def is_git_repo():
         try:
-            ret = run(['git', 'rev-parse', '--is-inside-work-tree'],
+            ret = run(['git', '-C', shared.options.binaryen_root, 'rev-parse', '--is-inside-work-tree'],
                       silent=True, stderr=subprocess.DEVNULL)
             return ret == 'true\n'
         except subprocess.CalledProcessError:
@@ -1008,7 +1008,7 @@ def __init__(self):
                     D8(),
                     D8Liftoff(),
                     D8Turboshaft(),
-                    # FIXME: Temprorary disable. See issue #4741 for more details
+                    # FIXME: Temporary disable. See issue #4741 for more details
                     # Wasm2C(),
                     # Wasm2C2Wasm()
                     ]
@@ -1372,7 +1372,7 @@ def handle_pair(self, input, before_wasm, after_wasm, opts):
             # "[fuzz-exec] export bar".
             call_start = before.rfind(FUZZ_EXEC_EXPORT_PREFIX, 0, trap_index)
             if call_start < 0:
-                # the trap happened before we called an export, so it occured
+                # the trap happened before we called an export, so it occurred
                 # during startup (the start function, or memory segment
                 # operations, etc.). in that case there is nothing for us to
                 # compare here; just leave.
@@ -2336,6 +2336,10 @@ def do_run(vm, js, wasm):
                 #
                 # Ignore it, as details of traces differ based on optimizations.
                 continue
+            elif not line:
+                # V8 may print blank lines before stack traces when the top
+                # frame has no script location (e.g. after a return_call to JS).
+                continue
             cleaned.append(line)
         cleaned = '\n'.join(cleaned)
 
@@ -2575,7 +2579,7 @@ def handle(self, wasm):
     TrapsNeverHappen(),
     CtorEval(),
     Merge(),
-#    Split(), # Will reenable after stabilized
+#    Split(), # Will re-enable after stabilized
     RoundtripText(),
     ClusterFuzz(),
     Two(),
@@ -2765,6 +2769,7 @@ def write_commands(commands, filename):
     ("--simplify-locals-notee",),
     ("--simplify-locals-notee-nostructure",),
     ("--ssa",),
+    ("--tail-call",),
     ("--tuple-optimization",),
     ("--type-finalizing",),
     ("--type-refining",),
@@ -3014,6 +3019,7 @@ def get_random_opts():
                 working_wasm = abspath('w.wasm')
                 wasm_reduce = in_bin('wasm-reduce')
                 reduce_sh = abspath('reduce.sh')
+                fuzz_opt = in_binaryen('scripts', 'fuzz_opt.py')
                 features = ' '.join(FEATURE_OPTS)
                 with open('reduce.sh', 'w') as f:
                     f.write(f'''\
@@ -3026,12 +3032,12 @@ def get_random_opts():
 
 if [ -z "$BINARYEN_FIRST_WASM" ]; then
   # run the command normally
-  ./scripts/fuzz_opt.py {auto_init} --binaryen-bin {binaryen_bin} {seed} {temp_wasm} > o 2> e
+  {fuzz_opt} {auto_init} --binaryen-bin {binaryen_bin} {seed} {temp_wasm} > o 2> e
 else
   # BINARYEN_FIRST_WASM was provided so we should actually reduce the *second*
   # file. pass the first one in as the main file, and use the env var for the
   # second.
-  BINARYEN_SECOND_WASM={temp_wasm} ./scripts/fuzz_opt.py {auto_init} --binaryen-bin {binaryen_bin} {seed} $BINARYEN_FIRST_WASM > o 2> e
+  BINARYEN_SECOND_WASM={temp_wasm} {fuzz_opt} {auto_init} --binaryen-bin {binaryen_bin} {seed} $BINARYEN_FIRST_WASM > o 2> e
 fi
 
 echo "  " $?
diff --git a/scripts/gen-s-parser.py b/scripts/gen-s-parser.py
index 93c70b7d755..3012c7dd7ab 100755
--- a/scripts/gen-s-parser.py
+++ b/scripts/gen-s-parser.py
@@ -219,6 +219,7 @@
     ("memory.atomic.wait64",    "makeAtomicWait(Type::i64)"),
     ("atomic.fence",            "makeAtomicFence()"),
     ("pause",                   "makePause()"),
+    ("publish",                 "makePublish()"),
     ("i32.atomic.load8_u",      "makeLoad(Type::i32, /*signed=*/false, 1, /*isAtomic=*/true)"),
     ("i32.atomic.load16_u",     "makeLoad(Type::i32, /*signed=*/false, 2, /*isAtomic=*/true)"),
     ("i32.atomic.load",         "makeLoad(Type::i32, /*signed=*/false, 4, /*isAtomic=*/true)"),
diff --git a/scripts/monitor_fuzz.py b/scripts/monitor_fuzz.py
new file mode 100755
index 00000000000..40b088ebd5a
--- /dev/null
+++ b/scripts/monitor_fuzz.py
@@ -0,0 +1,392 @@
+#!/usr/bin/env python3
+
+# Copyright 2026 WebAssembly Community Group participants
+#
+# 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.
+
+"""Run and monitor the Binaryen fuzzer (fuzz_opt.py).
+
+Monitors progress, manages log file truncation, stops at iteration limits,
+and reports bugs found.
+"""
+
+import argparse
+import collections
+import os
+import re
+import signal
+import subprocess
+import sys
+import threading
+import time
+
+
+class FuzzMonitor:
+    """Monitors fuzzer output stream, manages log files, and tracks state."""
+
+    def __init__(self, log_path, max_lines, keep_lines, truncate_interval):
+        self.log_path = log_path
+        self.max_lines = max_lines
+        self.keep_lines = keep_lines
+        self.truncate_interval = truncate_interval
+
+        self.lock = threading.Lock()
+        self.latest_iteration = 0
+        self.latest_seed = 'unknown'
+        self.bug_found = False
+        self.recent_lines = collections.deque(maxlen=20)
+
+        self.deque = collections.deque(maxlen=keep_lines)
+        self.lines_written = 0
+
+        if os.path.isfile(log_path):
+            try:
+                with open(log_path, encoding='utf-8', errors='replace') as f:
+                    for line in f:
+                        self.deque.append(line)
+                        self.lines_written += 1
+            except Exception:
+                pass
+
+    def _parse_line(self, line):
+        iter_match = re.search(r'ITERATION:\s*(\d+)', line)
+        if iter_match:
+            self.latest_iteration = int(iter_match.group(1))
+
+        seed_match = re.search(r'seed:\s*(\d+)', line)
+        if seed_match:
+            self.latest_seed = seed_match.group(1)
+
+        if re.search(r'You found a bug', line, re.IGNORECASE):
+            self.bug_found = True
+
+    def run(self, stdout_stream):
+        last_truncate = time.time()
+        try:
+            with open(self.log_path, 'a', encoding='utf-8') as f:
+                for line in stdout_stream:
+                    with self.lock:
+                        self._parse_line(line)
+                        self.deque.append(line)
+                        self.recent_lines.append(line)
+                        self.lines_written += 1
+
+                    f.write(line)
+                    f.flush()
+
+                    now = time.time()
+                    if (
+                        self.lines_written >= self.max_lines
+                        and (now - last_truncate) >= self.truncate_interval
+                    ):
+                        f.close()
+                        with open(self.log_path, 'w', encoding='utf-8') as wf:
+                            with self.lock:
+                                wf.writelines(self.deque)
+                                self.lines_written = len(self.deque)
+                        f = open(self.log_path, 'a', encoding='utf-8')
+                        last_truncate = now
+        except Exception as e:
+            print(f'Error writing to log file: {e}', file=sys.stderr)
+
+    def get_progress(self):
+        with self.lock:
+            return self.latest_iteration
+
+    def get_status(self):
+        with self.lock:
+            return (
+                self.bug_found,
+                self.latest_iteration,
+                self.latest_seed,
+                list(self.recent_lines),
+            )
+
+
+class FuzzerWorker:
+    """Manages a single fuzzer subprocess and its monitor."""
+
+    def __init__(
+        self,
+        worker_id,
+        work_dir,
+        cmd,
+        env,
+        max_lines,
+        keep_lines,
+        truncate_interval,
+    ):
+        self.id = worker_id
+        self.work_dir = work_dir
+        os.makedirs(work_dir, exist_ok=True)
+        self.log_path = os.path.join(work_dir, 'fuzz.log')
+        self.monitor = FuzzMonitor(
+            log_path=self.log_path,
+            max_lines=max_lines,
+            keep_lines=keep_lines,
+            truncate_interval=truncate_interval,
+        )
+        worker_env = env.copy()
+        worker_env['BINARYEN_OUT_DIR'] = work_dir
+        self.proc = subprocess.Popen(
+            cmd,
+            cwd=work_dir,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+            bufsize=1,
+            env=worker_env,
+            errors='replace',
+            start_new_session=True,
+        )
+        self.reader_thread = threading.Thread(
+            target=self.monitor.run,
+            args=(self.proc.stdout,),
+            daemon=True,
+        )
+        self.reader_thread.start()
+
+
+def parse_args():
+    # N.B. We could alternatively `import shared from test`, which has the side
+    # effect of changing the current directory to <binaryen_root>/out/test, but
+    # this is less magical.
+    binaryen_root = os.path.dirname(
+        os.path.dirname(os.path.abspath(__file__)))
+    default_log_dir = os.path.join(binaryen_root, 'out', 'test')
+    cores = os.cpu_count() or 1
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        '-j',
+        '--jobs',
+        type=int,
+        nargs='?',
+        const=cores,
+        default=int(os.environ.get('JOBS', '1')),
+        help=(
+            f'Number of parallel fuzzers to run (default: $JOBS or 1; '
+            f'defaults to {cores} if passed without an argument)'
+        ),
+    )
+    parser.add_argument(
+        '--log-dir',
+        default=os.environ.get('LOG_DIR', default_log_dir),
+        help='Directory to save fuzz logs (default: $LOG_DIR or out/test)',
+    )
+    parser.add_argument(
+        '--max-iters',
+        type=int,
+        default=int(os.environ.get('MAX_ITERS', '0')),
+        help='Stop after N total iterations across all fuzzers (0 for infinite, default: $MAX_ITERS or 0)',
+    )
+    parser.add_argument(
+        '--truncate-interval',
+        type=float,
+        default=30.0,
+        help='Seconds between log truncation checks (default: 30)',
+    )
+    parser.add_argument(
+        '--max-lines',
+        type=int,
+        default=10000,
+        help='Maximum lines in log before truncation (default: 10000)',
+    )
+    parser.add_argument(
+        '--keep-lines',
+        type=int,
+        default=5000,
+        help='Lines to keep when truncating (default: 5000)',
+    )
+    parser.add_argument(
+        'cmd',
+        nargs=argparse.REMAINDER,
+        help='Fuzzer command to run (default: ./scripts/fuzz_opt.py)',
+    )
+    args = parser.parse_args()
+    if args.jobs < 1:
+        parser.error('--jobs must be at least 1')
+    return args
+
+
+def main():
+    args = parse_args()
+
+    cmd = list(args.cmd)
+    if cmd and cmd[0] == '--':
+        cmd.pop(0)
+    if not cmd:
+        default_fuzzer = os.path.join(
+            os.path.dirname(os.path.abspath(__file__)), 'fuzz_opt.py',
+        )
+        cmd = [sys.executable, default_fuzzer]
+    else:
+        cmd = [
+            os.path.abspath(arg) if os.path.exists(arg) else arg for arg in cmd
+        ]
+
+    env = os.environ.copy()
+    env['PYTHONUNBUFFERED'] = '1'
+
+    workers = []
+    for i in range(args.jobs):
+        work_dir = os.path.join(args.log_dir, str(i))
+        workers.append(
+            FuzzerWorker(
+                worker_id=i,
+                work_dir=work_dir,
+                cmd=cmd,
+                env=env,
+                max_lines=args.max_lines,
+                keep_lines=args.keep_lines,
+                truncate_interval=args.truncate_interval,
+            ),
+        )
+
+    if len(workers) == 1:
+        print(
+            f'Fuzzer started with PID {workers[0].proc.pid}. Monitoring...',
+            flush=True,
+        )
+    else:
+        pids = ', '.join(str(w.proc.pid) for w in workers)
+        print(
+            f'Started {len(workers)} fuzzers with PIDs {pids}. Monitoring...',
+            flush=True,
+        )
+
+    def stop_children():
+        for w in workers:
+            if w.proc.poll() is None:
+                try:
+                    os.killpg(w.proc.pid, signal.SIGTERM)
+                except ProcessLookupError:
+                    pass
+        deadline = time.time() + 5.0
+        for w in workers:
+            if w.proc.poll() is None:
+                remaining = max(0.0, deadline - time.time())
+                try:
+                    w.proc.wait(timeout=remaining)
+                except subprocess.TimeoutExpired:
+                    try:
+                        os.killpg(w.proc.pid, signal.SIGKILL)
+                    except ProcessLookupError:
+                        pass
+                    w.proc.wait()
+
+    def signal_handler(signum, _frame):
+        stop_children()
+        for w in workers:
+            w.reader_thread.join(timeout=2.0)
+        sys.exit(128 + signum)
+
+    signal.signal(signal.SIGINT, signal_handler)
+    signal.signal(signal.SIGTERM, signal_handler)
+
+    start_time = time.time()
+    last_report = 0
+    limit_reached = False
+    stopped_worker = None
+
+    try:
+        while any(
+            w.reader_thread.is_alive() or w.proc.poll() is None for w in workers
+        ):
+            time.sleep(0.2)
+            now = time.time()
+            elapsed = int(now - start_time)
+
+            minute = elapsed // 60
+            total_iters = sum(w.monitor.get_progress() for w in workers)
+
+            if minute > last_report:
+                last_report = minute
+                timestamp = time.strftime('%H:%M:%S')
+                print(
+                    f'[{timestamp}] Runtime: {last_report} min,'
+                    f' Iterations: {total_iters}',
+                    flush=True,
+                )
+
+            if args.max_iters > 0 and total_iters >= args.max_iters:
+                fuzzer_str = 'fuzzer' if len(workers) == 1 else 'fuzzers'
+                print(
+                    f'Reached max iterations ({args.max_iters}). Stopping'
+                    f' {fuzzer_str}...',
+                    flush=True,
+                )
+                limit_reached = True
+                stop_children()
+                break
+
+            should_stop = False
+            for w in workers:
+                if w.monitor.get_status()[0]:
+                    try:
+                        w.proc.wait(timeout=2.0)
+                    except subprocess.TimeoutExpired:
+                        pass
+                    w.reader_thread.join(timeout=2.0)
+                    stopped_worker = w
+                    should_stop = True
+                    break
+                if w.proc.poll() is not None:
+                    w.reader_thread.join(timeout=2.0)
+                    stopped_worker = w
+                    should_stop = True
+                    break
+
+            if should_stop:
+                stop_children()
+                break
+    finally:
+        stop_children()
+        for w in workers:
+            w.reader_thread.join(timeout=5.0)
+
+    for w in workers:
+        bug_found, iteration, seed, _ = w.monitor.get_status()
+        if bug_found:
+            print('SUCCESS: Bug found!')
+            if len(workers) > 1:
+                print(f'Fuzzer: {w.id}')
+            print(f'Directory: {w.work_dir}')
+            print(f'Iteration: {iteration}')
+            print(f'Seed: {seed}')
+            print(f'Exit code: {w.proc.returncode}')
+            return 1
+
+    if limit_reached:
+        print(
+            f'SUCCESS: Reached max iterations ({args.max_iters}) without finding'
+            ' a bug.',
+        )
+        return 0
+
+    failed_worker = stopped_worker or workers[0]
+    _, _, _, recent_lines = failed_worker.monitor.get_status()
+
+    print('FAILURE: Fuzzer stopped unexpectedly without finding a bug.')
+    if len(workers) > 1:
+        print(f'Fuzzer: {failed_worker.id}')
+    print(f'Directory: {failed_worker.work_dir}')
+    print(f'Exit code: {failed_worker.proc.returncode}')
+    if recent_lines:
+        print('Last 20 lines of log:')
+        for line in recent_lines:
+            print(line.rstrip('\r\n'))
+    return 2
+
+
+if __name__ == '__main__':
+    sys.exit(main())
diff --git a/scripts/test/fuzzing.py b/scripts/test/fuzzing.py
index 1dafecfe570..a091689f7e2 100644
--- a/scripts/test/fuzzing.py
+++ b/scripts/test/fuzzing.py
@@ -93,7 +93,7 @@
     'string-lifting-section.wast',
     # TODO: fuzzer support for uninhabitable imported globals
     'exact-references.wast',
-    # We do not have full suppor for these imports in all parts of the fuzzer.
+    # We do not have full support for these imports in all parts of the fuzzer.
     'instrument-branch-hints.wast',
     # Contains a subtype chain that exceeds depth limits.
     'reorder-types-real.wast',
@@ -117,6 +117,9 @@
     # Not fully implemented.
     'waitqueue.wast',
     'gufa-waitqueue.wast',
+    'optimize-instructions-waitqueue.wast',
+    'publish.wast',
+    'optimize-instructions-publish.wast',
     # TODO: fix handling of the non-utf8 names here
     'name-high-bytes.wast',
     # JS interop testcases have complex js-wasm interactions
diff --git a/scripts/test/shared.py b/scripts/test/shared.py
index bd5bd9dc43b..0e65e159056 100644
--- a/scripts/test/shared.py
+++ b/scripts/test/shared.py
@@ -17,12 +17,14 @@
 import difflib
 import fnmatch
 import glob
+import io
 import os
 import shutil
 import stat
 import subprocess
 import sys
 from contextlib import contextmanager
+from multiprocessing.pool import ThreadPool
 from pathlib import Path
 
 # The C++ standard whose features are required to build Binaryen.
@@ -126,6 +128,63 @@ def verbose_log(*args, **kwargs):
         print(*args, **kwargs)
 
 
+@contextmanager
+def red_output(file=sys.stderr):
+    print("\033[31m", end="", file=file)
+    try:
+        yield
+    finally:
+        print("\033[0m", end="", file=file)
+
+
+def red_stderr():
+    return red_output(file=sys.stderr)
+
+
+def run_parallel_tests(run_one_test_func, tests, show_worker_count=True):
+    global num_failures
+    tests = list(tests)
+    if not tests:
+        return
+    worker_count = min(os.cpu_count() or 1, len(tests))
+    if show_worker_count:
+        print(f"Running with {worker_count} workers")
+
+    def run_test_with_wrapped_stdout(test):
+        out = io.StringIO()
+        try:
+            run_one_test_func(test, stdout=out)
+        except Exception as e:
+            print(e, file=out)
+            return False, out.getvalue()
+        return True, out.getvalue()
+
+    failed_stdouts = []
+    with ThreadPool(processes=worker_count) as pool:
+        try:
+            for success, stdout in pool.imap_unordered(run_test_with_wrapped_stdout, tests):
+                if success:
+                    print(stdout, end="")
+                    continue
+
+                num_failures += 1
+                failed_stdouts.append(stdout)
+                if options.abort_on_first_failure:
+                    with red_stderr():
+                        print("Aborted test execution after first failure. Set --no-fail-fast to disable this.", file=sys.stderr)
+                    break
+        except KeyboardInterrupt:
+            # Hard exit to avoid threads continuing to run after Ctrl-C.
+            # There's no concern of deadlocking during shutdown here.
+            os._exit(1)
+
+    if failed_stdouts:
+        with red_stderr():
+            print("Failed tests:", file=sys.stderr)
+            for failed in failed_stdouts:
+                print(failed, end="", file=sys.stderr)
+
+
 # setup
 
 # Locate Binaryen source directory if not specified.
@@ -157,7 +216,8 @@ def verbose_log(*args, **kwargs):
 options.binaryen_test = os.path.join(options.binaryen_root, 'test')
 
 if not options.out_dir:
-    options.out_dir = os.path.join(options.binaryen_root, 'out', 'test')
+    default_out_dir = os.path.join(options.binaryen_root, 'out', 'test')
+    options.out_dir = os.environ.get('BINARYEN_OUT_DIR', default_out_dir)
 
 if not os.path.exists(options.out_dir):
     os.makedirs(options.out_dir)
@@ -500,6 +560,12 @@ def binary_format_check(wast, verify_final_result=True, base_name=None, stdout=N
     return disassembled_file
 
 
+def pass_debug_env():
+    env = os.environ.copy()
+    env['BINARYEN_PASS_DEBUG'] = '1'
+    return env
+
+
 @contextmanager
 def with_pass_debug():
     old_pass_debug = os.environ.get('BINARYEN_PASS_DEBUG')
diff --git a/scripts/test/support.py b/scripts/test/support.py
index eab86044889..6d06999e944 100644
--- a/scripts/test/support.py
+++ b/scripts/test/support.py
@@ -136,7 +136,8 @@ def _subprocess_run(*args, **kwargs):
 
 
 def run_command(cmd, expected_status=0, stdout=None, stderr=None,
-                expected_err=None, err_contains=False, err_ignore=None):
+                expected_err=None, err_contains=False, err_ignore=None,
+                *, env=None):
     """Run a subprocess, returning its output.
 
     stderr - None, subprocess.PIPE, subprocess.STDOUT or a file handle / io.StringIO to write stdout to
@@ -149,7 +150,7 @@ def run_command(cmd, expected_status=0, stdout=None, stderr=None,
         stderr = subprocess.PIPE
     print('executing: ', ' '.join(cmd), file=stdout)
 
-    out, err, code = _subprocess_run(cmd, stdout=subprocess.PIPE, stderr=stderr, encoding='UTF-8')
+    out, err, code = _subprocess_run(cmd, stdout=subprocess.PIPE, stderr=stderr, encoding='UTF-8', env=env)
 
     if expected_status is not None and code != expected_status:
         raise Exception(f"run_command `{' '.join(cmd)}` failed ({code}) {err or ''}")
diff --git a/scripts/test/wasm2js.py b/scripts/test/wasm2js.py
index 76b788841e9..541ef222d82 100644
--- a/scripts/test/wasm2js.py
+++ b/scripts/test/wasm2js.py
@@ -57,7 +57,86 @@ def check_for_stale_files():
             shared.fail_with_error(f'orphan test output: {f}')
 
 
+def run_one_wasm2js_test(item, stdout=None):
+    t, opt, expected_file = item
+    basename = os.path.basename(t)
+    print('..', basename, file=stdout)
+
+    # Include the path to avoid collisions between test suites (e.g. lit/basic,
+    # spec, and wasm2js) when running in parallel.
+    # /path/to/binaryen/test/wasm2js/foo.wast -> wasm2js-foo
+    rel = os.path.relpath(t, shared.options.binaryen_test)
+    base_name = os.path.splitext(rel)[0].replace(os.sep, '-')
+    split_file = f'split_{base_name}_{opt}.wast'
+    mjs_file = f'a_{base_name}_{opt}.2asm.mjs'
+    asserts_mjs_file = f'a_{base_name}_{opt}.2asm.asserts.mjs'
+
+    all_js = []
+    all_out = ''
+
+    try:
+        for module, asserts in support.split_wast(t):
+            support.write_wast(split_file, module, asserts)
+
+            # wasm2js does not yet support EH or stack switching, and
+            # enabling them can reduce optimization opportunities
+            cmd = shared.WASM2JS + [split_file, '-all',
+                                    '--disable-exception-handling',
+                                    '--disable-stack-switching']
+            if opt:
+                cmd += ['-O']
+            if 'emscripten' in basename:
+                cmd += ['--emscripten']
+            if 'deterministic' in basename:
+                cmd += ['--deterministic']
+            js = support.run_command(cmd, stdout=stdout)
+            all_js.append(js)
+
+            if not shared.NODEJS and not shared.MOZJS:
+                print('No JS interpreters. Skipping spec tests.', file=stdout)
+                continue
+
+            with open(mjs_file, 'w') as f:
+                f.write(js)
+
+            cmd_asserts = cmd + ['--allow-asserts']
+            js_asserts = support.run_command(cmd_asserts, stdout=stdout)
+            # also verify it passes pass-debug verifications
+            support.run_command(cmd_asserts, stderr=subprocess.PIPE, stdout=stdout, env=shared.pass_debug_env())
+
+            with open(asserts_mjs_file, 'w') as f:
+                f.write(js_asserts)
+
+            # verify asm.js is valid js, note that we're using --experimental-modules
+            # to enable ESM syntax and we're also passing a custom loader to handle the
+            # `spectest` and `env` modules in our tests.
+            if shared.NODEJS:
+                loader = os.path.join(shared.options.binaryen_root, 'scripts', 'test', 'node-esm-loader.mjs')
+                node = [shared.NODEJS, '--experimental-modules', '--no-warnings', '--loader', loader]
+                cmd_node = node[:]
+                cmd_node.append(mjs_file)
+                out = support.run_command(cmd_node, stdout=stdout)
+                shared.fail_if_not_identical(out, '')
+                cmd_node = node[:]
+                cmd_node.append(asserts_mjs_file)
+                out = support.run_command(cmd_node, expected_err='', err_ignore='ExperimentalWarning', stdout=stdout)
+                all_out += out
+
+        shared.fail_if_not_identical_to_file(''.join(all_js), expected_file)
+        expected_out = os.path.join(shared.get_test_dir('spec'), 'expected-output', basename + '.log')
+        if os.path.exists(expected_out):
+            expected_out_text = open(expected_out).read()
+        else:
+            expected_out_text = ''
+        shared.fail_if_not_identical(all_out, expected_out_text)
+    finally:
+        shared.delete_from_orbit(split_file)
+        shared.delete_from_orbit(mjs_file)
+        shared.delete_from_orbit(asserts_mjs_file)
+
+
 def test_wasm2js_output():
+    tests = []
     for opt in (0, 1):
         for t in basic_tests + spec_tests + wasm2js_tests:
             basename = os.path.basename(t)
@@ -80,63 +159,9 @@ def test_wasm2js_output():
                 else:
                     raise Exception(f'missing expected file {expected_file}')
 
-            print('..', os.path.basename(t))
-
-            all_js = []
-            all_out = ''
-
-            for module, asserts in support.split_wast(t):
-                support.write_wast('split.wast', module, asserts)
-
-                # wasm2js does not yet support EH, and enabling it can reduce
-                # optimization opportunities
-                cmd = shared.WASM2JS + ['split.wast', '-all',
-                                        '--disable-exception-handling']
-                if opt:
-                    cmd += ['-O']
-                if 'emscripten' in basename:
-                    cmd += ['--emscripten']
-                if 'deterministic' in basename:
-                    cmd += ['--deterministic']
-                js = support.run_command(cmd)
-                all_js.append(js)
-
-                if not shared.NODEJS and not shared.MOZJS:
-                    print('No JS interpreters. Skipping spec tests.')
-                    continue
+            tests.append((t, opt, expected_file))
 
-                open('a.2asm.mjs', 'w').write(js)
-
-                cmd += ['--allow-asserts']
-                js = support.run_command(cmd)
-                # also verify it passes pass-debug verifications
-                with shared.with_pass_debug():
-                    support.run_command(cmd, stderr=subprocess.PIPE)
-
-                open('a.2asm.asserts.mjs', 'w').write(js)
-
-                # verify asm.js is valid js, note that we're using --experimental-modules
-                # to enable ESM syntax and we're also passing a custom loader to handle the
-                # `spectest` and `env` modules in our tests.
-                if shared.NODEJS:
-                    loader = os.path.join(shared.options.binaryen_root, 'scripts', 'test', 'node-esm-loader.mjs')
-                    node = [shared.NODEJS, '--experimental-modules', '--no-warnings', '--loader', loader]
-                    cmd = node[:]
-                    cmd.append('a.2asm.mjs')
-                    out = support.run_command(cmd)
-                    shared.fail_if_not_identical(out, '')
-                    cmd = node[:]
-                    cmd.append('a.2asm.asserts.mjs')
-                    out = support.run_command(cmd, expected_err='', err_ignore='ExperimentalWarning')
-                    all_out += out
-
-            shared.fail_if_not_identical_to_file(''.join(all_js), expected_file)
-            expected_out = os.path.join(shared.get_test_dir('spec'), 'expected-output', os.path.basename(t) + '.log')
-            if os.path.exists(expected_out):
-                expected_out = open(expected_out).read()
-            else:
-                expected_out = ''
-            shared.fail_if_not_identical(all_out, expected_out)
+    shared.run_parallel_tests(run_one_wasm2js_test, tests)
 
 
 def test_asserts_output():
@@ -150,7 +175,8 @@ def test_asserts_output():
 
         wasm = os.path.join(shared.get_test_dir('wasm2js'), wasm)
         cmd = shared.WASM2JS + [wasm, '--allow-asserts', '-all',
-                                '--disable-exception-handling']
+                                '--disable-exception-handling',
+                                '--disable-stack-switching']
         out = support.run_command(cmd)
         shared.fail_if_not_identical_to_file(out, asserts_expected_file)
 
@@ -201,10 +227,11 @@ def update_wasm2js_tests():
             for module, asserts in support.split_wast(t):
                 support.write_wast('split.wast', module, asserts)
 
-                # wasm2js does not yet support EH, and enable it can reduce
-                # optimization opportunities
+                # wasm2js does not yet support EH or stack switching, and
+                # enabling them can reduce optimization opportunities
                 cmd = shared.WASM2JS + ['split.wast', '-all',
-                                        '--disable-exception-handling']
+                                        '--disable-exception-handling',
+                                        '--disable-stack-switching']
                 if opt:
                     cmd += ['-O']
                 if 'emscripten' in basename:
@@ -225,7 +252,7 @@ def update_wasm2js_tests():
         asserts_expected_file = os.path.join(shared.options.binaryen_test, 'wasm2js', asserts)
         traps_expected_file = os.path.join(shared.options.binaryen_test, 'wasm2js', traps)
 
-        cmd = shared.WASM2JS + [os.path.join(shared.get_test_dir('wasm2js'), wasm), '--allow-asserts', '-all', '--disable-exception-handling']
+        cmd = shared.WASM2JS + [os.path.join(shared.get_test_dir('wasm2js'), wasm), '--allow-asserts', '-all', '--disable-exception-handling', '--disable-stack-switching']
         out = support.run_command(cmd)
         with open(asserts_expected_file, 'w') as o:
             o.write(out)
diff --git a/scripts/test/wasm_opt.py b/scripts/test/wasm_opt.py
index de51497139c..7b2ea147371 100644
--- a/scripts/test/wasm_opt.py
+++ b/scripts/test/wasm_opt.py
@@ -15,12 +15,74 @@
 import os
 import shutil
 import subprocess
-import sys
 
 from . import shared, support
 from .shared import print_heading
 
 
+def run_one_pass_test(t, stdout=None):
+    # windows has some failures that need to be investigated:
+    # * ttf tests have different outputs - order of execution of params?
+    # * dwarf tests print windows slashes instead of unix
+    if ('translate-to-fuzz' in t or 'dwarf' in t) and \
+       shared.skip_if_on_windows('fuzz translation tests'):
+        return
+    print('..', os.path.basename(t), file=stdout)
+    binary = t.endswith('.wasm')
+    base = os.path.basename(t).replace('.wast', '').replace('.wasm', '')
+    passname = base
+    passes_file = os.path.join(shared.get_test_dir('passes'), passname + '.passes')
+    if os.path.exists(passes_file):
+        passname = open(passes_file).read().strip()
+    passes = [p for p in passname.split('_') if p != 'noprint']
+    opts = [('--' + p if not p.startswith('O') and p != 'g' else '-' + p) for p in passes]
+    actual = ''
+    split_wast = f'split_{base}.wast'
+    try:
+        for module, asserts in support.split_wast(t):
+            assert len(asserts) == 0
+            support.write_wast(split_wast, module)
+            cmd = shared.WASM_OPT + opts + [split_wast, '-q']
+            if 'noprint' not in t:
+                cmd.append('--print')
+            curr = support.run_command(cmd, stdout=stdout)
+            actual += curr
+            # also check debug mode output is valid
+            debugged = support.run_command(cmd + ['--debug'], stderr=subprocess.PIPE, stdout=stdout)
+            shared.fail_if_not_contained(actual, debugged)
+
+            # also check pass-debug mode
+            # ignore stderr, as the pass-debug output is very verbose in CI
+            pass_debug = support.run_command(cmd, stderr=subprocess.PIPE, stdout=stdout, env=shared.pass_debug_env())
+            shared.fail_if_not_identical(curr, pass_debug)
+
+        expected_file = os.path.join(shared.get_test_dir('passes'), base + ('.bin' if binary else '') + '.txt')
+        shared.fail_if_not_identical_to_file(actual, expected_file)
+
+        if 'emit-js-wrapper' in t:
+            with open('a.js') as actual_wrapper:
+                shared.fail_if_not_identical_to_file(actual_wrapper.read(), t + '.js')
+        if 'emit-spec-wrapper' in t:
+            with open('a.wat') as actual_wrapper:
+                shared.fail_if_not_identical_to_file(actual_wrapper.read(), t + '.wat')
+    finally:
+        shared.delete_from_orbit(split_wast)
+
+
+def run_one_print_test(t, stdout=None):
+    print('..', os.path.basename(t), file=stdout)
+    wasm = os.path.basename(t).replace('.wast', '')
+    cmd = shared.WASM_OPT + [t, '--print', '-all']
+    print('    ', ' '.join(cmd), file=stdout)
+    proc = subprocess.run(cmd, capture_output=True, text=True)
+    expected_file = os.path.join(shared.get_test_dir('print'), wasm + '.txt')
+    shared.fail_if_not_identical_to_file(proc.stdout, expected_file)
+    cmd = shared.WASM_OPT + [os.path.join(shared.get_test_dir('print'), t), '--print-minified', '-all']
+    print('    ', ' '.join(cmd), file=stdout)
+    proc = subprocess.run(cmd, capture_output=True, text=True)
+    shared.fail_if_not_identical(proc.stdout.strip(), open(os.path.join(shared.get_test_dir('print'), wasm + '.minified.txt')).read().strip())
+
+
 def test_wasm_opt():
     print_heading('checking wasm-opt -o notation...')
 
@@ -43,72 +105,12 @@ def test_wasm_opt():
     assert open('b.wast', 'rb').read()[0] != 0, 'we emit text with -S'
 
     print_heading('checking wasm-opt passes...')
-
-    for t in shared.get_tests(shared.get_test_dir('passes'), ['.wast', '.wasm']):
-        print('..', os.path.basename(t))
-        # windows has some failures that need to be investigated:
-        # * ttf tests have different outputs - order of execution of params?
-        # * dwarf tests print windows slashes instead of unix
-        if ('translate-to-fuzz' in t or 'dwarf' in t) and \
-           shared.skip_if_on_windows('fuzz translation tests'):
-            continue
-        binary = t.endswith('.wasm')
-        base = os.path.basename(t).replace('.wast', '').replace('.wasm', '')
-        passname = base
-        passes_file = os.path.join(shared.get_test_dir('passes'), passname + '.passes')
-        if os.path.exists(passes_file):
-            passname = open(passes_file).read().strip()
-        passes = [p for p in passname.split('_') if p != 'noprint']
-        opts = [('--' + p if not p.startswith('O') and p != 'g' else '-' + p) for p in passes]
-        actual = ''
-        for module, asserts in support.split_wast(t):
-            # Flush stdout/stderr between each test.  This prevent confusing
-            # interleaving in output of github CI
-            # TODO: Find a better, more systematic way to achieve this that
-            # works for all test suites.
-            sys.stdout.flush()
-            sys.stderr.flush()
-            assert len(asserts) == 0
-            support.write_wast('split.wast', module)
-            cmd = shared.WASM_OPT + opts + ['split.wast', '-q']
-            if 'noprint' not in t:
-                cmd.append('--print')
-            curr = support.run_command(cmd)
-            actual += curr
-            # also check debug mode output is valid
-            debugged = support.run_command(cmd + ['--debug'], stderr=subprocess.PIPE)
-            shared.fail_if_not_contained(actual, debugged)
-
-            # also check pass-debug mode
-            with shared.with_pass_debug():
-                # ignore stderr, as the pass-debug output is very verbose in CI
-                pass_debug = support.run_command(cmd, stderr=subprocess.PIPE)
-                shared.fail_if_not_identical(curr, pass_debug)
-
-        expected_file = os.path.join(shared.get_test_dir('passes'), base + ('.bin' if binary else '') + '.txt')
-        shared.fail_if_not_identical_to_file(actual, expected_file)
-
-        if 'emit-js-wrapper' in t:
-            with open('a.js') as actual:
-                shared.fail_if_not_identical_to_file(actual.read(), t + '.js')
-        if 'emit-spec-wrapper' in t:
-            with open('a.wat') as actual:
-                shared.fail_if_not_identical_to_file(actual.read(), t + '.wat')
+    passes_tests = shared.get_tests(shared.get_test_dir('passes'), ['.wast', '.wasm'])
+    shared.run_parallel_tests(run_one_pass_test, passes_tests)
 
     print_heading('checking wasm-opt parsing & printing...')
-
-    for t in shared.get_tests(shared.get_test_dir('print'), ['.wast']):
-        print('..', os.path.basename(t))
-        wasm = os.path.basename(t).replace('.wast', '')
-        cmd = shared.WASM_OPT + [t, '--print', '-all']
-        print('    ', ' '.join(cmd))
-        proc = subprocess.run(cmd, capture_output=True, text=True)
-        expected_file = os.path.join(shared.get_test_dir('print'), wasm + '.txt')
-        shared.fail_if_not_identical_to_file(proc.stdout, expected_file)
-        cmd = shared.WASM_OPT + [os.path.join(shared.get_test_dir('print'), t), '--print-minified', '-all']
-        print('    ', ' '.join(cmd))
-        proc = subprocess.run(cmd, capture_output=True, text=True)
-        shared.fail_if_not_identical(proc.stdout.strip(), open(os.path.join(shared.get_test_dir('print'), wasm + '.minified.txt')).read().strip())
+    print_tests = shared.get_tests(shared.get_test_dir('print'), ['.wast'])
+    shared.run_parallel_tests(run_one_print_test, print_tests)
 
 
 def update_wasm_opt_tests():
diff --git a/scripts/update_help_checks.py b/scripts/update_help_checks.py
index 5471f3533a9..e7e3e0deb21 100755
--- a/scripts/update_help_checks.py
+++ b/scripts/update_help_checks.py
@@ -39,11 +39,13 @@ def main():
             out.write(f';; RUN: {tool} --help | filecheck %s' + os.linesep)
             first = True
             for line in output.splitlines():
-                if first:
-                    out.write(f';; CHECK: {line}'.strip() + os.linesep)
+                if not line:
+                    out.write(';; CHECK-EMPTY:' + os.linesep)
+                elif first:
+                    out.write(f';; CHECK: {line}' + os.linesep)
                     first = False
                 else:
-                    out.write(f';; CHECK-NEXT: {line}'.strip() + os.linesep)
+                    out.write(f';; CHECK-NEXT: {line}' + os.linesep)
 
 
 if __name__ == '__main__':
diff --git a/scripts/update_lit_checks.py b/scripts/update_lit_checks.py
index d399fae8493..0e6801e663c 100755
--- a/scripts/update_lit_checks.py
+++ b/scripts/update_lit_checks.py
@@ -167,7 +167,7 @@ def find_annotations(module, start):
                 else:
                     # Found something that isn't an annotation.
                     break
-    # Look for the start of the line containin the first annoation.
+    # Look for the start of the line containing the first annotation.
     for i in range(annotation - 1, -1, -1):
         if module[i] == '\n':
             return i + 1
@@ -331,7 +331,7 @@ def update_test(args, test, lines, tmp):
 
     prefixes = {prefix for module_output in command_output for prefix in module_output.keys()}
     check_line_re = re.compile(r'^\s*;;\s*(' + '|'.join(prefixes) +
-                               r')(?:-NEXT|-LABEL|-NOT)?:.*$')
+                               r')(?:-[A-Z0-9]+)?:.*$')
 
     # Filter out whitespace between check blocks
     if lines:
@@ -353,8 +353,14 @@ def update_test(args, test, lines, tmp):
     def emit_checks(indent, prefix, lines):
         def pad(line):
             return line if not line or line.startswith(' ') else ' ' + line
-        output_lines.append(f'{indent};; {prefix}:     {pad(lines[0])}')
-        output_lines.extend(f'{indent};; {prefix}-NEXT:{pad(line)}' for line in lines[1:])
+
+        for i, line in enumerate(lines):
+            if not line.strip():
+                output_lines.append(f'{indent};; {prefix}-EMPTY:')
+            elif i == 0:
+                output_lines.append(f'{indent};; {prefix}:     {pad(line)}')
+            else:
+                output_lines.append(f'{indent};; {prefix}-NEXT:{pad(line)}')
 
     input_modules = [m.split('\n') for m in split_modules('\n'.join(lines))]
     if len(input_modules) > len(command_output):
diff --git a/src/binaryen-c.cpp b/src/binaryen-c.cpp
index 2f2f0d3ddac..3d2f776b20a 100644
--- a/src/binaryen-c.cpp
+++ b/src/binaryen-c.cpp
@@ -1949,6 +1949,10 @@ BinaryenExpressionRef BinaryenWaitqueueNotify(BinaryenModuleRef module,
   return Builder(*(Module*)module)
     .makeWaitqueueNotify((Expression*)waitqueue, (Expression*)count);
 }
+BinaryenExpressionRef BinaryenPublish(BinaryenModuleRef module,
+                                      BinaryenExpressionRef ref) {
+  return Builder(*(Module*)module).makePublish((Expression*)ref);
+}
 BinaryenExpressionRef BinaryenArrayNew(BinaryenModuleRef module,
                                        BinaryenHeapType type,
                                        BinaryenExpressionRef size,
@@ -4788,6 +4792,20 @@ void BinaryenWaitqueueNotifySetCount(BinaryenExpressionRef expr,
   static_cast<WaitqueueNotify*>(expression)->count = (Expression*)countExpr;
 }
 
+// Publish
+BinaryenExpressionRef BinaryenPublishGetRef(BinaryenExpressionRef expr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Publish>());
+  return static_cast<Publish*>(expression)->ref;
+}
+void BinaryenPublishSetRef(BinaryenExpressionRef expr,
+                           BinaryenExpressionRef refExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Publish>());
+  assert(refExpr);
+  static_cast<Publish*>(expression)->ref = (Expression*)refExpr;
+}
+
 // ArrayNew
 BinaryenExpressionRef BinaryenArrayNewGetInit(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
@@ -6846,6 +6864,10 @@ BinaryenSideEffects BinaryenSideEffectDanglingPop(void) {
   return static_cast<BinaryenSideEffects>(
     EffectAnalyzer::SideEffects::DanglingPop);
 }
+BinaryenSideEffects BinaryenSideEffectSuspends(void) {
+  return static_cast<BinaryenSideEffects>(
+    EffectAnalyzer::SideEffects::Suspends);
+}
 BinaryenSideEffects BinaryenSideEffectAny(void) {
   return static_cast<BinaryenSideEffects>(EffectAnalyzer::SideEffects::Any);
 }
diff --git a/src/binaryen-c.h b/src/binaryen-c.h
index d550e42d04e..1754e60dde6 100644
--- a/src/binaryen-c.h
+++ b/src/binaryen-c.h
@@ -1124,6 +1124,8 @@ BINARYEN_API BinaryenExpressionRef
 BinaryenWaitqueueNotify(BinaryenModuleRef module,
                         BinaryenExpressionRef waitqueue,
                         BinaryenExpressionRef count);
+BINARYEN_API BinaryenExpressionRef BinaryenPublish(BinaryenModuleRef module,
+                                                   BinaryenExpressionRef ref);
 BINARYEN_API BinaryenExpressionRef BinaryenArrayNew(BinaryenModuleRef module,
                                                     BinaryenHeapType type,
                                                     BinaryenExpressionRef size,
@@ -2702,6 +2704,13 @@ BINARYEN_API void
 BinaryenWaitqueueNotifySetCount(BinaryenExpressionRef expr,
                                 BinaryenExpressionRef countExpr);
 
+// Publish
+
+BINARYEN_API BinaryenExpressionRef
+BinaryenPublishGetRef(BinaryenExpressionRef expr);
+BINARYEN_API void BinaryenPublishSetRef(BinaryenExpressionRef expr,
+                                        BinaryenExpressionRef refExpr);
+
 // ArrayNew
 
 BINARYEN_API BinaryenExpressionRef
@@ -3753,6 +3762,7 @@ BINARYEN_API BinaryenSideEffects BinaryenSideEffectTrapsNeverHappen(void);
 BINARYEN_API BinaryenSideEffects BinaryenSideEffectIsAtomic(void);
 BINARYEN_API BinaryenSideEffects BinaryenSideEffectThrows(void);
 BINARYEN_API BinaryenSideEffects BinaryenSideEffectDanglingPop(void);
+BINARYEN_API BinaryenSideEffects BinaryenSideEffectSuspends(void);
 BINARYEN_API BinaryenSideEffects BinaryenSideEffectAny(void);
 
 BINARYEN_API BinaryenSideEffects BinaryenExpressionGetSideEffects(
@@ -3808,10 +3818,10 @@ BINARYEN_API void RelooperAddBranchForSwitch(RelooperBlockRef from,
                                              BinaryenIndex numIndexes,
                                              BinaryenExpressionRef code);
 
-// Generate structed wasm control flow from the CFG of blocks and branches that
-// were created on this relooper instance. This returns the rendered output, and
-// also disposes of the relooper and its blocks and branches, as they are no
-// longer needed.
+// Generate structured wasm control flow from the CFG of blocks and branches
+// that were created on this relooper instance. This returns the rendered
+// output, and also disposes of the relooper and its blocks and branches, as
+// they are no longer needed.
 // @param labelHelper To render irreducible control flow, we may need a helper
 //        variable to guide us to the right target label. This value should be
 //        an index of an i32 local variable that is free for us to use.
diff --git a/src/dataflow/node.h b/src/dataflow/node.h
index d88134a2feb..c529f2040c2 100644
--- a/src/dataflow/node.h
+++ b/src/dataflow/node.h
@@ -55,7 +55,7 @@ struct Node {
           // in wasm)
     Expr, // a value represented by a Binaryen Expression
     Phi,  // a phi from converging control flow
-    Cond, // a blockpc, representing one of the branchs for a Block
+    Cond, // a blockpc, representing one of the branches for a Block
     Block, // a source of phis
     Zext, // zero-extend an i1 (from an op where Souper returns i1 but wasm does
           // not, and so we need a special way to get back to an i32/i64 if we
diff --git a/src/gen-s-parser.inc b/src/gen-s-parser.inc
index 6288b5b2734..7d7e5887b2c 100644
--- a/src/gen-s-parser.inc
+++ b/src/gen-s-parser.inc
@@ -4948,6 +4948,12 @@ switch (buf[0]) {
           return Ok{};
         }
         goto parse_error;
+      case 'u':
+        if (op == "publish"sv) {
+          CHECK_ERR(makePublish(ctx, pos, annotations));
+          return Ok{};
+        }
+        goto parse_error;
       default: goto parse_error;
     }
   }
diff --git a/src/interpreter/interpreter.cpp b/src/interpreter/interpreter.cpp
index d7f31a6ddf0..878752e38e0 100644
--- a/src/interpreter/interpreter.cpp
+++ b/src/interpreter/interpreter.cpp
@@ -259,6 +259,7 @@ struct ExpressionInterpreter : OverriddenVisitor<ExpressionInterpreter, Flow> {
   Flow visitStructWait(StructWait* curr) { WASM_UNREACHABLE("TODO"); }
   Flow visitWaitqueueNew(WaitqueueNew* curr) { WASM_UNREACHABLE("TODO"); }
   Flow visitWaitqueueNotify(WaitqueueNotify* curr) { WASM_UNREACHABLE("TODO"); }
+  Flow visitPublish(Publish* curr) { WASM_UNREACHABLE("TODO"); }
   Flow visitArrayNew(ArrayNew* curr) { WASM_UNREACHABLE("TODO"); }
   Flow visitArrayNewData(ArrayNewData* curr) { WASM_UNREACHABLE("TODO"); }
   Flow visitArrayNewElem(ArrayNewElem* curr) { WASM_UNREACHABLE("TODO"); }
@@ -311,7 +312,7 @@ Result<> Interpreter::instantiate(Instance& instance) {
   return Ok{};
 }
 
-// This is a temporary convenience while stil using gTests to validate this
+// This is a temporary convenience while still using gTests to validate this
 // interpreter. Once spec tests can run, this shall be deleted.
 std::vector<Literal> Interpreter::runTest(Expression* root) {
   static std::shared_ptr<wasm::Module> dummyModule = std::make_shared<Module>();
diff --git a/src/ir/ReFinalize.cpp b/src/ir/ReFinalize.cpp
index 8e5b6c801ee..32fb39f314c 100644
--- a/src/ir/ReFinalize.cpp
+++ b/src/ir/ReFinalize.cpp
@@ -170,6 +170,7 @@ void ReFinalize::visitWaitqueueNew(WaitqueueNew* curr) { curr->finalize(); }
 void ReFinalize::visitWaitqueueNotify(WaitqueueNotify* curr) {
   curr->finalize();
 }
+void ReFinalize::visitPublish(Publish* curr) { curr->finalize(); }
 void ReFinalize::visitArrayNew(ArrayNew* curr) { curr->finalize(); }
 void ReFinalize::visitArrayNewData(ArrayNewData* curr) { curr->finalize(); }
 void ReFinalize::visitArrayNewElem(ArrayNewElem* curr) { curr->finalize(); }
diff --git a/src/ir/child-typer.h b/src/ir/child-typer.h
index 27499b785fb..21d59a88bfb 100644
--- a/src/ir/child-typer.h
+++ b/src/ir/child-typer.h
@@ -83,7 +83,7 @@ template<typename Subtype> struct ChildTyper : OverriddenVisitor<Subtype> {
     }
   }
 
-  // Disambiguate betwween Type and VarType.
+  // Disambiguate between Type and VarType.
   void note(Expression** childp, Type::BasicType type) {
     note(childp, VarType{Type(type)});
   }
@@ -1056,6 +1056,11 @@ template<typename Subtype> struct ChildTyper : OverriddenVisitor<Subtype> {
     note(&curr->count, Type(Type::BasicType::i32));
   }
 
+  void visitPublish(Publish* curr) {
+    // Polymorphic over heap types.
+    note(&curr->ref, VarRef{Nullable, VarHeapType{0u}});
+  }
+
   void visitArrayNew(ArrayNew* curr) {
     if (!curr->isWithDefault()) {
       if (!curr->type.isRef()) {
diff --git a/src/ir/constraint.cpp b/src/ir/constraint.cpp
index c38c97162b6..0c9cc14fefe 100644
--- a/src/ir/constraint.cpp
+++ b/src/ir/constraint.cpp
@@ -17,6 +17,7 @@
 #include <optional>
 
 #include "ir/constraint.h"
+#include "ir/find_all.h"
 #include "ir/properties.h"
 #include "wasm.h"
 
@@ -255,6 +256,66 @@ Result provesConstantPair(Abstract::Op aOp,
   return Unknown;
 }
 
+// Evaluate whether a => b, where a and b are operations on identical terms.
+Result provesTermEqualPair(Abstract::Op aOp, Abstract::Op bOp) {
+  using namespace Abstract;
+
+  // Trivial cases where aOp == bOp or aOp == !bOp are taken care of elsewhere.
+  assert(aOp != bOp && aOp != Abstract::negateRelational(bOp));
+
+  switch (aOp) {
+    case Eq:
+      // == proves >= etc. true, and > (without =) false
+      if (bOp == LeU || bOp == LeS || bOp == GeU || bOp == GeS) {
+        return True;
+      }
+      if (bOp == LtU || bOp == LtS || bOp == GtU || bOp == GtS) {
+        return False;
+      }
+      break;
+    case LtS:
+      // < proves <=, != true and ==, > false
+      if (bOp == LeS || bOp == Ne) {
+        return True;
+      }
+      if (bOp == Eq || bOp == GtS) {
+        return False;
+      }
+      break;
+    case GtS:
+      // Ditto, with G instead of L.
+      if (bOp == GeS || bOp == Ne) {
+        return True;
+      }
+      if (bOp == Eq || bOp == LtS) {
+        return False;
+      }
+      break;
+    case LtU:
+      // Ditto, with unsigned.
+      if (bOp == LeU || bOp == Ne) {
+        return True;
+      }
+      if (bOp == Eq || bOp == GtU) {
+        return False;
+      }
+      break;
+    case GtU:
+      // Ditto, with G instead of L.
+      if (bOp == GeU || bOp == Ne) {
+        return True;
+      }
+      if (bOp == Eq || bOp == LtU) {
+        return False;
+      }
+      break;
+    default: {
+    }
+  }
+
+  return Unknown;
+}
+
 // Core comparison of two constraints: whether a => b
 Result provesPair(const Constraint& a, const Constraint& b) {
   // A thing always implies itself.
@@ -309,6 +370,10 @@ Result provesPair(const Constraint& a, const Constraint& b) {
     }
   }
 
+  if (a.term == b.term) {
+    return provesTermEqualPair(a.op, b.op);
+  }
+
   return Unknown;
 }
 
@@ -669,22 +734,130 @@ bool AndedConstraintSet::approximateOr(const AndedConstraintSet& other) {
   return changed;
 }
 
-std::optional<LocalConstraint> LocalConstraint::parse(Expression* curr) {
+namespace {
+
+// Internal parsing, utilizing a map of tees. We can handle tees in an
+// expression, so long as they do not interfere with each other:
+//
+//  (i32.eq
+//    (local.tee $x ..)
+//    (i32.const 10)
+//  )
+//
+// We can parse this into $x == 10, just as if we saw a local.get $x there. But
+// we cannot handle this:
+//
+//  (i32.eq
+//    (local.get $x)
+//    (local.tee $x ..)
+//  )
+//
+// Parsing this into $x == $x would be wrong: the first $x is the old value.
+// That is, fully handling tees requires a more SSA-like IR. To handle the
+// common cases we want to, we parse the code in the natural order of execution,
+// and maintain a list of local operations. A get before a tee indicates
+// possible interference.
+struct LocalOperations {
+  SmallVector<Expression*, 10> vec;
+
+  // Check if an Expression returns a local's value: it is either a get or a
+  // tee. Returns the index and type if so, and notes it in our vector.
+  struct LocalOperation {
+    Index index;
+  };
+  std::optional<LocalOperation> parse(Expression* curr) {
+    auto handleNestedSets = [&](Expression* from) {
+      for (auto* nested : FindAll<LocalSet>(from).list) {
+        vec.push_back(nested);
+      }
+    };
+
+    if (auto* get = curr->dynCast<LocalGet>()) {
+      vec.push_back(get);
+      return LocalOperation{get->index};
+    }
+    if (auto* set = curr->dynCast<LocalSet>()) {
+      // We are parsing expressions in a tree, not none-typed items in a block.
+      assert(set->isTee());
+
+      // We know the value of this expression - the local the tee writes to -
+      // but further sets may be nested in the value, affecting other locals.
+      handleNestedSets(set->value);
+
+      // Ignore unreachable code, so the callers don't need to handle it.
+      if (set->type == Type::unreachable) {
+        return {};
+      }
+
+      vec.push_back(set);
+      return LocalOperation{set->index};
+    }
+    // Unrecognized. As above, we must scan for nested sets.
+    handleNestedSets(curr);
+    return {};
+  }
+
+  // Check for any possible interference between locals, which would tell the
+  // caller that whatever was parsed is not valid.
+  bool hasLocalInterference() const {
+    if (vec.size() <= 1) {
+      return false;
+    }
+
+    // Process the list in detail, as interference - a get before a set of the
+    // same local - is possible. We track the read locals, and if we see a
+    // later write, that shows a problem.
+    std::unordered_set<Index> read;
+    for (auto* curr : vec) {
+      if (auto* get = curr->dynCast<LocalGet>()) {
+        read.insert(get->index);
+      } else if (auto* set = curr->dynCast<LocalSet>()) {
+        if (read.contains(set->index)) {
+          return true;
+        }
+        // Insert a read, because the tee does both a write and a read.
+        if (set->isTee()) {
+          read.insert(set->index);
+        }
+      } else {
+        WASM_UNREACHABLE("invalid local op");
+      }
+    }
+    return false;
+  }
+};
+
+std::optional<LocalConstraint>
+localConstraintParseInternal(Expression* curr,
+                             LocalOperations& localOperations) {
+  using namespace Match;
+
   auto parseEqZArgument =
     [&](Expression* value) -> std::optional<LocalConstraint> {
-    if (auto* get = value->dynCast<LocalGet>()) {
+    if (auto localOp = localOperations.parse(value)) {
       // Canonicalize EqZ to Eq of 0.
-      auto value = Literal::makeZero(get->type);
-      return LocalConstraint{get->index, Constraint{Abstract::Eq, {value}}};
+      auto zero = Literal::makeZero(value->type);
+      return LocalConstraint{localOp->index, Constraint{Abstract::Eq, {zero}}};
     }
     // TODO: Recursively parse and reverse a constraint
     return {};
   };
 
-  if (auto* unary = curr->dynCast<Unary>()) {
-    if (Abstract::getUnary(unary->value->type, Abstract::EqZ) == unary->op) {
-      return parseEqZArgument(unary->value);
+  if (auto* u = curr->dynCast<Unary>()) {
+    if (Abstract::getUnary(u->value->type, Abstract::EqZ) == u->op) {
+      // EqZ of EqZ means a check that the value is *not* zero.
+      Expression* nested;
+      if (matches(u->value, unary(Abstract::EqZ, any(&nested)))) {
+        if (auto localOp = localOperations.parse(nested)) {
+          auto value = Literal::makeZero(nested->type);
+          return LocalConstraint{localOp->index,
+                                 Constraint{Abstract::Ne, {value}}};
+        }
+      }
+
+      return parseEqZArgument(u->value);
     }
+
     return {};
   }
 
@@ -692,10 +865,10 @@ std::optional<LocalConstraint> LocalConstraint::parse(Expression* curr) {
     return parseEqZArgument(refIsNull->value);
   }
 
-  // Parse a get or a constant.
+  // Parse a get, tee, or a constant.
   auto parseTerm = [&](Expression* expr) -> std::optional<Term> {
-    if (auto* get = expr->dynCast<LocalGet>()) {
-      return Term{get->index};
+    if (auto localOp = localOperations.parse(expr)) {
+      return Term{localOp->index};
     }
     if (Properties::isSingleConstantExpression(expr)) {
       return Term{Properties::getLiteral(expr)};
@@ -707,11 +880,11 @@ std::optional<LocalConstraint> LocalConstraint::parse(Expression* curr) {
     [&](Abstract::Op op,
         Expression* left,
         Expression* right) -> std::optional<LocalConstraint> {
-    // The left must be a get.
-    if (auto* get = left->dynCast<LocalGet>()) {
+    // The left must be a get or a tee.
+    if (auto localOp = localOperations.parse(left)) {
       // The right can be any term.
       if (auto value = parseTerm(right)) {
-        return LocalConstraint{get->index, Constraint{op, *value}};
+        return LocalConstraint{localOp->index, Constraint{op, *value}};
       }
     }
     return {};
@@ -743,17 +916,129 @@ std::optional<LocalConstraint> LocalConstraint::parse(Expression* curr) {
   return {};
 }
 
-std::optional<LocalConstraint>
-LocalConstraint::parseCondition(Expression* curr) {
-  // A get by itself is a check for not being null.
-  if (auto* get = curr->dynCast<LocalGet>()) {
-    auto value = Literal::makeZero(get->type);
-    return LocalConstraint{get->index, Constraint{Abstract::Ne, {value}}};
+} // anonymous namespace
+
+std::optional<LocalConstraint> LocalConstraint::parse(Expression* curr) {
+  LocalOperations localOperations;
+  auto ret = localConstraintParseInternal(curr, localOperations);
+  if (localOperations.hasLocalInterference()) {
+    return {};
+  }
+  return ret;
+}
+
+ParsedAndedConstraints ParsedAndedConstraints::parse(Expression* curr) {
+  using namespace Match;
+
+  // The final return value.
+  ParsedAndedConstraints ret;
+
+  // We will track local operations over the entire tree we parse.
+  LocalOperations localOperations;
+
+  // Starting from |curr|, parse and recurse into sub-trees: when we see an AND,
+  // we push both children as further work.
+  SmallVector<Expression*, 4> work;
+  work.push_back(curr);
+  while (!work.empty()) {
+    auto* curr = work.back();
+    work.pop_back();
+
+    auto parsed = localConstraintParseInternal(curr, localOperations);
+    if (parsed) {
+      ret.push_back(*parsed);
+      continue;
+    }
+
+    Binary* b;
+    if (matches(curr, binary(&b, Abstract::And, any(), any()))) {
+      // An AND can be recursively processed: both sides must be true. Push them
+      // in reverse order, so we process them in the natural order of execution.
+      work.push_back(b->right);
+      work.push_back(b->left);
+      continue;
+    }
+    // TODO: support OR
+
+    // We failed to parse this as constraints. We do still need to check for
+    // local operations that might interfere with the things we did parse,
+    // otherwise.
+    localOperations.parse(curr);
+    ret.hasUnknown = true;
+  }
+
+  if (localOperations.hasLocalInterference()) {
+    return {};
+  }
+  return ret;
+}
+
+ParsedAndedConstraints
+ParsedAndedConstraints::parseCondition(Expression* curr) {
+  // A get or tee by itself is a check for not being null.
+  LocalOperations localOperations;
+  if (auto localOp = localOperations.parse(curr)) {
+    auto value = Literal::makeZero(curr->type);
+    return {LocalConstraint{localOp->index, Constraint{Abstract::Ne, {value}}}};
   }
 
   // Otherwise, parse normally.
   return parse(curr);
-};
+}
+
+void ParsedAndedConstraints::negate() {
+  if (empty()) {
+    return;
+  }
+
+  if (hasUnknown) {
+    // This includes things we don't know about, and don't know how to negate.
+    clear();
+    return;
+  }
+
+  // The input is a list of constraints all applying at once, A & B & C. The
+  // negation is !A | !B | !C, but we cannot express a general OR like that,
+  // except in the simple case where they all talk about the same local: then
+  // we can at least approximateOr them all into one constraint.
+  auto& self = *this;
+  for (Index i = 1; i < size(); i++) {
+    if (self[i].local != self[0].local) {
+      // They refer to different locals. Give up.
+      clear();
+      return;
+    }
+  }
+
+  // Negate them before the OR.
+  for (auto& pair : self) {
+    pair.constraint = pair.constraint.negate();
+  }
+
+  if (size() == 1) {
+    // The simple case of 1 doesn't need any more work.
+    return;
+  }
+
+  // Do the OR.
+  AndedConstraintSet anded;
+  anded.set(self[0].constraint);
+  for (Index i = 1; i < size(); i++) {
+    anded.approximateOr({self[i].constraint});
+    if (anded.provesNothing()) {
+      // We have nothing useful here.
+      clear();
+      return;
+    }
+  }
+
+  // Return only the OR'ed result.
+  auto local = self[0].local;
+  clear();
+  for (auto& c : anded) {
+    emplace_back(local, c);
+  }
+}
 
 void LocalConstraint::flip() {
   auto other = std::get<Index>(constraint.term);
@@ -1088,6 +1373,11 @@ std::ostream& operator<<(std::ostream& o, const Constraint& c) {
   return o;
 }
 
+std::ostream& operator<<(std::ostream& o, const LocalConstraint& c) {
+  o << "LocalConstraint{$" << c.local << ", " << c.constraint << '}';
+  return o;
+}
+
 std::ostream& operator<<(std::ostream& o, const AndedConstraintSet& set) {
   if (set.provesEverything()) {
     o << "AndedConstraintSet(contradiction)";
diff --git a/src/ir/constraint.h b/src/ir/constraint.h
index d699fc4c424..2e15bec5ff0 100644
--- a/src/ir/constraint.h
+++ b/src/ir/constraint.h
@@ -32,6 +32,7 @@
 
 #include "ir/abstract.h"
 #include "support/inplace_vector.h"
+#include "support/small_vector.h"
 #include "support/span.h"
 #include "support/utilities.h"
 #include "wasm.h"
@@ -235,6 +236,12 @@ struct LocalConstraint {
   Index local;
   Constraint constraint;
 
+  LocalConstraint() = default;
+  LocalConstraint(Index local, Constraint constraint)
+    : local(local), constraint(std::move(constraint)) {}
+
+  bool operator==(const LocalConstraint&) const = default;
+
   // Try to parse BinaryenIR into a local to which a constraint is applied. For
   // example
   //
@@ -246,15 +253,43 @@ struct LocalConstraint {
   //
   static std::optional<LocalConstraint> parse(Expression* curr);
 
-  // Parse in a condition context, i.e., where (local.get $x) is the same as
-  // $x != 0 (e.g., in an if condition, or a br_on ref).
-  static std::optional<LocalConstraint> parseCondition(Expression* curr);
-
   // Reverse the constraint. The constraint's term must, of course, be another
   // local.
   void flip();
 };
 
+// A utility to parse BinaryenIR into locals and constraints on them. This is
+// similar to LocalConstraint::parse, but that parses a single constraint, while
+// this can handle a list of ANDed ones:
+//
+//   (i32.and (..A..) (..B..))
+//
+// parses into [ A, B ].
+//
+// We also set a field |hasUnknown| if we saw things we could not parse. E.g.
+//
+//   (i32.and (call $unknown) (i32.eqz (local.get $x)))
+//
+// This parses into [ $x == 0 ] and sets hasUnknown=true. Even if there are
+// unknown things, we do know that definitely $x == 0 at least, which is useful
+// in some cases.
+struct ParsedAndedConstraints : public SmallVector<LocalConstraint, 1> {
+  using SmallVector<LocalConstraint, 1>::SmallVector;
+
+  bool hasUnknown = false;
+
+  static ParsedAndedConstraints parse(Expression* curr);
+
+  // Parse in a condition context, i.e., where (local.get $x) is the same as
+  // $x != 0 (e.g., in an if condition, or a br_on ref).
+  static ParsedAndedConstraints parseCondition(Expression* curr);
+
+  // Negate the entire list of constraints. If we fail to generate something
+  // that can be represented as a list of ANDed constraints, the list will be
+  // empty (i.e., we can prove nothing).
+  void negate();
+};
+
 // A map of locals and their constraints, representing the state at a basic
 // block. We use the following representation:
 //
@@ -366,6 +401,7 @@ struct BasicBlockConstraintMap {
 };
 
 std::ostream& operator<<(std::ostream& o, const Constraint& c);
+std::ostream& operator<<(std::ostream& o, const LocalConstraint& c);
 std::ostream& operator<<(std::ostream& o, const AndedConstraintSet& set);
 
 } // namespace wasm::constraint
diff --git a/src/ir/cost.h b/src/ir/cost.h
index 13fa7cb8b13..f2789666369 100644
--- a/src/ir/cost.h
+++ b/src/ir/cost.h
@@ -128,6 +128,7 @@ struct CostAnalyzer : public OverriddenVisitor<CostAnalyzer, CostType> {
     return AtomicCost + nullCheckCost(curr->waitqueue) +
            visit(curr->waitqueue) + visit(curr->count);
   }
+  CostType visitPublish(Publish* curr) { return AtomicCost + visit(curr->ref); }
   CostType visitAtomicNotify(AtomicNotify* curr) {
     return AtomicCost + visit(curr->ptr) + visit(curr->notifyCount);
   }
diff --git a/src/ir/effects.cpp b/src/ir/effects.cpp
index 017057a1349..a8d36085f2b 100644
--- a/src/ir/effects.cpp
+++ b/src/ir/effects.cpp
@@ -96,6 +96,9 @@ std::ostream& operator<<(std::ostream& o, const EffectAnalyzer& effects) {
   if (effects.throws_) {
     o << "throws_\n";
   }
+  if (effects.suspends) {
+    o << "suspends_\n";
+  }
   if (effects.tryDepth) {
     o << "tryDepth\n";
   }
diff --git a/src/ir/effects.h b/src/ir/effects.h
index 40bd93b6ba2..24e50e5d28c 100644
--- a/src/ir/effects.h
+++ b/src/ir/effects.h
@@ -23,7 +23,6 @@
 #include "ir/intrinsics.h"
 #include "pass.h"
 #include "support/name.h"
-#include "support/utilities.h"
 #include "wasm-traversal.h"
 #include "wasm-type.h"
 #include "wasm.h"
@@ -44,8 +43,8 @@ class EffectAnalyzer {
       readsMutableArray(false), writesArray(false),
       readsSharedMutableArray(false), writesSharedArray(false), trap(false),
       implicitTrap(false), throws_(false), danglingPop(false),
-      mayNotReturn(false), hasReturnCallThrow(false), module(module),
-      features(module.features) {}
+      mayNotReturn(false), hasReturnCallThrow(false), suspends(false),
+      module(module), features(module.features) {}
 
   EffectAnalyzer(const PassOptions& passOptions,
                  const Module& module,
@@ -138,6 +137,8 @@ class EffectAnalyzer {
   // more here.)
   bool hasReturnCallThrow : 1;
 
+  bool suspends : 1;
+
   const Module& module;
   FeatureSet features;
 
@@ -228,15 +229,17 @@ class EffectAnalyzer {
     return calls || readsSharedMutableArray || writesSharedArray;
   }
   bool throws() const { return throws_ || !delegateTargets.empty(); }
+
   // Check whether this may transfer control flow to somewhere outside of this
-  // expression (aside from just flowing out normally). That includes a break
-  // or a throw (if the throw is not known to be caught inside this expression;
+  // expression (aside from just flowing out normally). That includes a break,
+  // a throw (if the throw is not known to be caught inside this expression;
   // note that if the throw is not caught in this expression then it might be
   // caught in this function but outside of this expression, or it might not be
   // caught in the function at all, which would mean control flow cannot be
-  // transferred inside the function, but this expression does not know that).
+  // transferred inside the function, but this expression does not know that),
+  // or a suspension.
   bool transfersControlFlow() const {
-    return branchesOut || throws() || hasExternalBreakTargets();
+    return branchesOut || suspends || throws() || hasExternalBreakTargets();
   }
 
   // Changes something in globally-stored state.
@@ -480,6 +483,7 @@ class EffectAnalyzer {
     danglingPop = danglingPop || other.danglingPop;
     mayNotReturn = mayNotReturn || other.mayNotReturn;
     hasReturnCallThrow = hasReturnCallThrow || other.hasReturnCallThrow;
+    suspends = suspends || other.suspends;
     readOrder = std::max(readOrder, other.readOrder);
     writeOrder = std::max(writeOrder, other.writeOrder);
 
@@ -1104,6 +1108,27 @@ class EffectAnalyzer {
       parent.writesSharedStruct = true;
       parent.readOrder = parent.writeOrder = MemoryOrder::SeqCst;
     }
+    void visitPublish(Publish* curr) {
+      // Publish is a no-op on anything besides shared structs and arrays.
+      if (!curr->ref->type.isRef()) {
+        return;
+      }
+      auto heapType = curr->ref->type.getHeapType();
+      if (!heapType.isShared()) {
+        return;
+      }
+      if (!heapType.isStruct() && !heapType.isMaybeShared(HeapType::struct_) &&
+          !heapType.isArray() && !heapType.isMaybeShared(HeapType::array) &&
+          !heapType.isMaybeShared(HeapType::eq) &&
+          !heapType.isMaybeShared(HeapType::any)) {
+        return;
+      }
+      // TODO: Modeling `publish` as an arbitrary call is overly conservative.
+      // We need to prevent writes to the published object from being moved
+      // after the publish and we need to prevent writes of the published object
+      // to anywhere else from being moved before the publish.
+      parent.calls = true;
+    }
     void visitArrayNew(ArrayNew* curr) {}
     void visitArrayNewData(ArrayNewData* curr) {
       // Traps on out of bounds access to segments or access to dropped
@@ -1271,8 +1296,9 @@ class EffectAnalyzer {
       parent.calls = true;
     }
     void visitSuspend(Suspend* curr) {
-      // Similar to resume/call: Suspending means that we execute arbitrary
-      // other code before we may resume here.
+      // Suspending transfers control to an enclosing handler and executes
+      // arbitrary other code before we may resume here.
+      parent.suspends = true;
       parent.calls = true;
       if (parent.features.hasExceptionHandling() && parent.tryDepth == 0) {
         parent.throws_ = true;
@@ -1370,12 +1396,27 @@ class EffectAnalyzer {
           parent.throws_ = true;
         }
       }
+      // If stack switching is enabled and we don't have global effects
+      // information, assume that the call target may suspend.
+      if (parent.features.hasStackSwitching()) {
+        parent.suspends = true;
+      }
     }
   };
 
 public:
   // Helpers
 
+  // See comment on orderedBefore() for the assumptions on the inputs here.
+  static bool orderedBefore(const PassOptions& passOptions,
+                            Module& module,
+                            Expression* a,
+                            Expression* b) {
+    EffectAnalyzer aEffects(passOptions, module, a);
+    EffectAnalyzer bEffects(passOptions, module, b);
+    return aEffects.orderedBefore(bEffects);
+  }
+
   // See comment on orderedBefore() for the assumptions on the inputs here.
   // TODO: Update users so we can check just one direction here.
   static bool canReorder(const PassOptions& passOptions,
@@ -1407,7 +1448,8 @@ class EffectAnalyzer {
     Throws = 1 << 12,
     DanglingPop = 1 << 13,
     TrapsNeverHappen = 1 << 14,
-    Any = (1 << 15) - 1
+    Suspends = 1 << 15,
+    Any = (1 << 16) - 1
   };
   uint32_t getSideEffects() const {
     uint32_t effects = 0;
@@ -1459,12 +1501,15 @@ class EffectAnalyzer {
     if (danglingPop) {
       effects |= SideEffects::DanglingPop;
     }
+    if (suspends) {
+      effects |= SideEffects::Suspends;
+    }
     return effects;
   }
 
-  // Ignores all forms of control flow transfers: breaks, returns, and
-  // exceptions. (Note that traps are not considered relevant here - a trap does
-  // not just transfer control flow, but can be seen as halting the entire
+  // Ignores all forms of control flow transfers: breaks, returns, exceptions,
+  // and suspensions. (Note that traps are not considered relevant here - a trap
+  // does not just transfer control flow, but can be seen as halting the entire
   // program.)
   //
   // This function matches transfersControlFlow(), that is, after calling this
@@ -1474,6 +1519,7 @@ class EffectAnalyzer {
     breakTargets.clear();
     throws_ = false;
     delegateTargets.clear();
+    suspends = false;
     assert(!transfersControlFlow());
   }
 
diff --git a/src/ir/js-utils.h b/src/ir/js-utils.h
index 105dea499cf..99d71e2388e 100644
--- a/src/ir/js-utils.h
+++ b/src/ir/js-utils.h
@@ -23,6 +23,18 @@
 
 namespace wasm::JSUtils {
 
+// Whether a field is immutable and a reference to a subtype of externref that
+// could hold a JS prototype.
+inline bool isPossibleJSPrototypeField(const Field& field) {
+  if (field.mutable_ != Immutable) {
+    return false;
+  }
+  if (!field.type.isRef()) {
+    return false;
+  }
+  return field.type.getHeapType().isMaybeShared(HeapType::ext);
+}
+
 // Whether this is a descriptor struct type whose first field is immutable and a
 // subtype of externref.
 inline bool hasPossibleJSPrototypeField(HeapType type) {
@@ -34,13 +46,7 @@ inline bool hasPossibleJSPrototypeField(HeapType type) {
   if (fields.empty()) {
     return false;
   }
-  if (fields[0].mutable_ == Mutable) {
-    return false;
-  }
-  if (!fields[0].type.isRef()) {
-    return false;
-  }
-  return fields[0].type.getHeapType().isMaybeShared(HeapType::ext);
+  return isPossibleJSPrototypeField(fields[0]);
 }
 
 // Calls flowIn and flowOut on all types that may flow in from or out to JS.
diff --git a/src/ir/linear-execution.h b/src/ir/linear-execution.h
index 9e69405ff7c..905160961c1 100644
--- a/src/ir/linear-execution.h
+++ b/src/ir/linear-execution.h
@@ -251,6 +251,7 @@ struct LinearExecutionWalker : public PostWalker<SubType, VisitorType> {
         if (!self->connectAdjacentBlocks) {
           self->pushTask(SubType::doNoteNonLinear, currp);
         }
+        self->maybePushTask(SubType::scan, &curr->cast<BrOn>()->desc);
         self->pushTask(SubType::scan, &curr->cast<BrOn>()->ref);
         break;
       }
diff --git a/src/ir/manipulation.h b/src/ir/manipulation.h
index dbb34edbe66..5058f82b972 100644
--- a/src/ir/manipulation.h
+++ b/src/ir/manipulation.h
@@ -21,7 +21,7 @@
 
 namespace wasm::ExpressionManipulator {
 
-// Re-use a node's memory. This helps avoid allocation when optimizing.
+// Reuse a node's memory. This helps avoid allocation when optimizing.
 template<typename InputType, typename OutputType>
 inline OutputType* convert(InputType* input) {
   static_assert(sizeof(OutputType) <= sizeof(InputType),
diff --git a/src/ir/match.h b/src/ir/match.h
index a60bad43235..4edba55ec4e 100644
--- a/src/ir/match.h
+++ b/src/ir/match.h
@@ -896,6 +896,9 @@ inline decltype(auto) local() {
 inline decltype(auto) local(Index* binder) {
   return Internal::LocalGetMatcher(nullptr, Internal::Any(binder));
 }
+inline decltype(auto) local(LocalGet** binder) {
+  return Internal::LocalGetMatcher(binder, Internal::Any<Index>(nullptr));
+}
 
 } // namespace wasm::Match
 
diff --git a/src/ir/module-splitting.cpp b/src/ir/module-splitting.cpp
index b340ad5f874..67b361fb946 100644
--- a/src/ir/module-splitting.cpp
+++ b/src/ir/module-splitting.cpp
@@ -156,7 +156,7 @@ TableSlotManager::TableSlotManager(
   Module& module, const std::vector<std::unique_ptr<Module>>& secondaries)
   : module(module), secondaries(secondaries) {
   // If possible, just create a new table to manage all primary-to-secondary
-  // calls lazily. Do not re-use slots for functions that will already be in
+  // calls lazily. Do not reuse slots for functions that will already be in
   // existing tables, since that is not correct in the face of table mutations.
   // However, do not do this for emscripten; its loader code (and dynamic
   // loading in particular) do not support this yet.
diff --git a/src/ir/module-utils.cpp b/src/ir/module-utils.cpp
index 8f3ee597c08..46dd332e102 100644
--- a/src/ir/module-utils.cpp
+++ b/src/ir/module-utils.cpp
@@ -358,7 +358,7 @@ struct TypeInfos {
 
   // Multivalue control flow structures need a function type, but the identity
   // of the function type (i.e. what recursion group it is in or whether it is
-  // final) doesn't matter. Save them for the end to see if we can re-use an
+  // final) doesn't matter. Save them for the end to see if we can reuse an
   // existing function type with the necessary signature.
   InsertOrderedMap<Signature, size_t> controlFlowSignatures;
 
diff --git a/src/ir/possible-contents.cpp b/src/ir/possible-contents.cpp
index f752fa10172..381d4e49441 100644
--- a/src/ir/possible-contents.cpp
+++ b/src/ir/possible-contents.cpp
@@ -1098,6 +1098,7 @@ struct InfoCollector
   void visitStructWait(StructWait* curr) { addRoot(curr); }
   void visitWaitqueueNew(WaitqueueNew* curr) { addRoot(curr); }
   void visitWaitqueueNotify(WaitqueueNotify* curr) { addRoot(curr); }
+  void visitPublish(Publish* curr) { receiveChildValue(curr->ref, curr); }
   // Array operations access the array's location, parallel to how structs work.
   void visitArrayGet(ArrayGet* curr) {
     if (!isRelevant(curr->ref)) {
@@ -1410,8 +1411,12 @@ struct InfoCollector
     // continuation values.
     auto numTags = curr->handlerTags.size();
     for (Index tagIndex = 0; tagIndex < numTags; tagIndex++) {
-      auto tag = curr->handlerTags[tagIndex];
       auto target = curr->handlerBlocks[tagIndex];
+      if (!target) {
+        // A switch handler does not branch to a target block.
+        continue;
+      }
+      auto tag = curr->handlerTags[tagIndex];
       auto params = getModule()->getTag(tag)->params();
 
       // Add the values from the tag.
@@ -1771,6 +1776,7 @@ void TNHOracle::scan(Function* func,
     void visitStructCmpxchg(StructCmpxchg* curr) {
       notePossibleTrap(curr->ref);
     }
+    // TODO: visitStructWait
     void visitArrayGet(ArrayGet* curr) { notePossibleTrap(curr->ref); }
     void visitArraySet(ArraySet* curr) { notePossibleTrap(curr->ref); }
     void visitArrayLoad(ArrayLoad* curr) { notePossibleTrap(curr->ref); }
diff --git a/src/ir/properties.cpp b/src/ir/properties.cpp
index 535f50dace4..a3dc9c45dc9 100644
--- a/src/ir/properties.cpp
+++ b/src/ir/properties.cpp
@@ -47,9 +47,23 @@ struct GenerativityScanner : public PostWalker<GenerativityScanner> {
   void visitArrayNewElem(ArrayNewElem* curr) { generative = true; }
   void visitArrayNewFixed(ArrayNewFixed* curr) { generative = true; }
   void visitContNew(ContNew* curr) { generative = true; }
+
+  // Notifications/waits depend on events on other threads.
+  void visitAtomicNotify(AtomicNotify* curr) { generative = true; }
+  void visitWaitqueueNotify(WaitqueueNotify* curr) { generative = true; }
+  void visitAtomicWait(AtomicWait* curr) { generative = true; }
+  void visitStructWait(StructWait* curr) { generative = true; }
   void visitWaitqueueNew(WaitqueueNew* curr) { generative = true; }
-  // TODO: waitqueue.notify, struct.wait, atomic.notify, and atomic.wait should
-  // also be generative.
+
+  // Instructions that both read and write memory are generative (as they
+  // themselves can lead to a different value being returned from identical-
+  // looking instructions; no other instruction in the middle is needed).
+  void visitAtomicRMW(AtomicRMW* curr) { generative = true; }
+  void visitAtomicCmpxchg(AtomicCmpxchg* curr) { generative = true; }
+  void visitStructRMW(StructRMW* curr) { generative = true; }
+  void visitStructCmpxchg(StructCmpxchg* curr) { generative = true; }
+  void visitArrayRMW(ArrayRMW* curr) { generative = true; }
+  void visitArrayCmpxchg(ArrayCmpxchg* curr) { generative = true; }
 };
 
 } // anonymous namespace
diff --git a/src/ir/properties.h b/src/ir/properties.h
index 4b4126d750d..59c35cf9cae 100644
--- a/src/ir/properties.h
+++ b/src/ir/properties.h
@@ -316,8 +316,8 @@ inline Expression** getImmediateFallthroughPtr(
     // know the fallthrough in that case.
     if (br->condition && br->value &&
         behavior == FallthroughBehavior::AllowTeeBrIf &&
-        EffectAnalyzer::canReorder(
-          passOptions, module, br->condition, br->value)) {
+        !EffectAnalyzer::orderedBefore(
+          passOptions, module, br->value, br->condition)) {
       return &br->value;
     }
   } else if (auto* tryy = curr->dynCast<Try>()) {
@@ -325,7 +325,10 @@ inline Expression** getImmediateFallthroughPtr(
       return &tryy->body;
     }
   } else if (auto* as = curr->dynCast<RefCast>()) {
-    return &as->ref;
+    if (!as->desc || (!EffectAnalyzer::orderedBefore(
+                       passOptions, module, as->ref, as->desc))) {
+      return &as->ref;
+    }
   } else if (auto* as = curr->dynCast<RefAs>()) {
     // Extern conversions are not casts and actually produce new values.
     // Treating them as fallthroughs would lead to misoptimizations of
@@ -334,7 +337,12 @@ inline Expression** getImmediateFallthroughPtr(
       return &as->value;
     }
   } else if (auto* br = curr->dynCast<BrOn>()) {
-    return &br->ref;
+    if (!br->desc || (!EffectAnalyzer::orderedBefore(
+                       passOptions, module, br->ref, br->desc))) {
+      return &br->ref;
+    }
+  } else if (auto* pub = curr->dynCast<Publish>()) {
+    return &pub->ref;
   }
   return currp;
 }
diff --git a/src/ir/struct-utils.h b/src/ir/struct-utils.h
index 471a580a9d4..c90fbb85348 100644
--- a/src/ir/struct-utils.h
+++ b/src/ir/struct-utils.h
@@ -287,6 +287,8 @@ struct StructScanner : public WalkerPass<PostWalker<SubType>> {
     noteExpressionOrCopy(curr->replacement, type, index, info);
   }
 
+  // TODO: visitStructWait
+
   void visitRefCast(RefCast* curr) {
     if (curr->desc) {
       // We may try to read a descriptor from anything arriving in |curr->ref|,
diff --git a/src/ir/subtype-exprs.h b/src/ir/subtype-exprs.h
index 2394fdd114a..603a5a6ecfd 100644
--- a/src/ir/subtype-exprs.h
+++ b/src/ir/subtype-exprs.h
@@ -50,7 +50,7 @@ namespace wasm {
 //                                    must be a subtype of the signature's
 //                                    param.
 //  * noteSubtype(Expression, Expression) - An expression's type must be a
-//                                          subtype of anothers, for example,
+//                                          subtype of another's, for example,
 //                                          a block and its last child.
 //
 //  * noteCast(HeapType, Type) - A fixed type is cast to another, for example,
@@ -397,6 +397,7 @@ struct SubtypingDiscoverer : public OverriddenVisitor<SubType> {
     self()->noteSubtype(curr->waitqueue,
                         Type(HeapTypes::sharedWaitqueue, Nullable));
   }
+  void visitPublish(Publish* curr) {}
   void visitArrayNew(ArrayNew* curr) {
     if (!curr->type.isArray() || curr->isWithDefault()) {
       return;
diff --git a/src/ir/trapping.h b/src/ir/trapping.h
deleted file mode 100644
index 6272bbf0f3c..00000000000
--- a/src/ir/trapping.h
+++ /dev/null
@@ -1,109 +0,0 @@
-/*
- * Copyright 2017 WebAssembly Community Group participants
- *
- * 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.
- */
-
-#ifndef wasm_ir_trapping_h
-#define wasm_ir_trapping_h
-
-#include <exception>
-
-#include "pass.h"
-
-namespace wasm {
-
-enum class TrapMode { Allow, Clamp, JS };
-
-inline void addTrapModePass(PassRunner& runner, TrapMode trapMode) {
-  if (trapMode == TrapMode::Clamp) {
-    runner.add("trap-mode-clamp");
-  } else if (trapMode == TrapMode::JS) {
-    runner.add("trap-mode-js");
-  }
-}
-
-class TrappingFunctionContainer {
-public:
-  TrappingFunctionContainer(TrapMode mode, Module& wasm, bool immediate = false)
-    : mode(mode), wasm(wasm), immediate(immediate) {}
-
-  bool hasFunction(Name name) {
-    return functions.find(name) != functions.end();
-  }
-  bool hasImport(Name name) { return imports.find(name) != imports.end(); }
-
-  void addFunction(Function* function) {
-    functions[function->name] = function;
-    if (immediate) {
-      wasm.addFunction(function);
-    }
-  }
-  void addImport(Function* import) {
-    imports[import->name] = import;
-    if (immediate) {
-      wasm.addFunction(import);
-    }
-  }
-
-  void addToModule() {
-    if (!immediate) {
-      for (auto& [_, func] : functions) {
-        wasm.addFunction(func);
-      }
-      for (auto& [_, func] : imports) {
-        wasm.addFunction(func);
-      }
-    }
-    functions.clear();
-    imports.clear();
-  }
-
-  TrapMode getMode() { return mode; }
-
-  Module& getModule() { return wasm; }
-
-  std::map<Name, Function*>& getFunctions() { return functions; }
-
-private:
-  std::map<Name, Function*> functions;
-  std::map<Name, Function*> imports;
-
-  TrapMode mode;
-  Module& wasm;
-  bool immediate;
-};
-
-Expression* makeTrappingBinary(Binary* curr,
-                               TrappingFunctionContainer& trappingFunctions);
-Expression* makeTrappingUnary(Unary* curr,
-                              TrappingFunctionContainer& trappingFunctions);
-
-inline TrapMode trapModeFromString(std::string const& str) {
-  if (str == "allow") {
-    return TrapMode::Allow;
-  } else if (str == "clamp") {
-    return TrapMode::Clamp;
-  } else if (str == "js") {
-    return TrapMode::JS;
-  } else {
-    throw std::invalid_argument(
-      "Unsupported trap mode \"" + str +
-      "\". "
-      "Valid modes are \"allow\", \"js\", and \"clamp\"");
-  }
-}
-
-} // namespace wasm
-
-#endif // wasm_ir_trapping_h
diff --git a/src/ir/type-updating.cpp b/src/ir/type-updating.cpp
index d325e539a9a..2643e3ea3c6 100644
--- a/src/ir/type-updating.cpp
+++ b/src/ir/type-updating.cpp
@@ -78,7 +78,7 @@ updateIndirectCallEffects(
       // oldType has no entry, which means its effects are explicitly unknown.
       // Why? It's a source type in `typeMap`, so it must have appeared in
       // the module at some point, but GlobalEffects were never computed for it,
-      // or GlobalEffects intentionally ommitted its entry because it couldn't
+      // or GlobalEffects intentionally omitted its entry because it couldn't
       // determine its effects (e.g. if an import has that type).
       newTypes.insert(destType);
       newTypeEffects.erase(destType);
diff --git a/src/js/binaryen.js-post.js b/src/js/binaryen.js-post.js
index b04996952eb..f9a6240e9b8 100644
--- a/src/js/binaryen.js-post.js
+++ b/src/js/binaryen.js-post.js
@@ -29,7 +29,9 @@ function i8sToStack(i8s) {
 function initializeConstants() {
 
   // Types
-  [ ['none', 'None'],
+  Module['Type'] = {};
+  [
+    ['none', 'None'],
     ['i32', 'Int32'],
     ['i64', 'Int64'],
     ['f32', 'Float32'],
@@ -51,9 +53,11 @@ function initializeConstants() {
     ['unreachable', 'Unreachable'],
     ['auto', 'Auto']
   ].forEach(entry => {
-    Module[entry[0]] = Module['_BinaryenType' + entry[1]]();
+    Module['Type'][entry[0]] = Module['_BinaryenType' + entry[1]]();
   });
 
+  // Heap types
+  Module['HeapType'] = {};
   [
     ['func', 'Func'],
     ['extern', 'Ext'],
@@ -63,24 +67,23 @@ function initializeConstants() {
     ['struct', 'Struct'],
     ['array', 'Array'],
     ['string', 'String'],
-    /*
-    TODO: Reconcile with `none` above (line 32).
-    Maybe keep this as 'none' and change the above to 'void'?
     ['none', 'None'],
-    */
     ['noextern', 'Noext'],
     ['nofunc', 'Nofunc'],
     ['exn', 'Exn'],
     ['noexn', 'Noexn'],
   ].forEach(entry => {
-    Module[entry[0]] = Module['_BinaryenHeapType' + entry[1]]();
+    Module['HeapType'][entry[0]] = Module['_BinaryenHeapType' + entry[1]]();
   });
 
-  [ ['notPacked', 'NotPacked'],
+  // Packed types
+  Module['PackedType'] = {};
+  [
+    ['notPacked', 'NotPacked'],
     ['i8', 'Int8'],
     ['i16', 'Int16']
   ].forEach(entry => {
-    Module[entry[0]] = Module['_BinaryenPackedType' + entry[1]]();
+    Module['PackedType'][entry[0]] = Module['_BinaryenPackedType' + entry[1]]();
   });
 
   // Expression ids
@@ -153,6 +156,7 @@ function initializeConstants() {
     'StructWait',
     'WaitqueueNew',
     'WaitqueueNotify',
+    'Publish',
     'ArrayNew',
     'ArrayNewFixed',
     'ArrayNewData',
@@ -672,6 +676,7 @@ function initializeConstants() {
     'Throws',
     'DanglingPop',
     'TrapsNeverHappen',
+    'Suspends',
     'Any'
   ].forEach(name => {
     Module['SideEffects'][name] = Module['_BinaryenSideEffect' + name]();
@@ -712,7 +717,7 @@ function wrapModule(module, self = {}) {
     return preserveStack(() =>
       Module['_BinaryenBlock'](module, name ? strToStack(name) : 0,
                                i32sToStack(children), children.length,
-                               typeof type !== 'undefined' ? type : Module['none'])
+                               typeof type !== 'undefined' ? type : Module['Type']['none'])
     );
   };
   self['if'] = function(condition, ifTrue, ifFalse) {
@@ -815,10 +820,10 @@ function wrapModule(module, self = {}) {
         return preserveStack(() => Module['_BinaryenAtomicNotify'](module, ptr, notifyCount, strToStack(name)));
       },
       'wait32'(ptr, expected, timeout, name) {
-        return preserveStack(() => Module['_BinaryenAtomicWait'](module, ptr, expected, timeout, Module['i32'], strToStack(name)));
+        return preserveStack(() => Module['_BinaryenAtomicWait'](module, ptr, expected, timeout, Module['Type']['i32'], strToStack(name)));
       },
       'wait64'(ptr, expected, timeout, name) {
-        return preserveStack(() => Module['_BinaryenAtomicWait'](module, ptr, expected, timeout, Module['i64'], strToStack(name)));
+        return preserveStack(() => Module['_BinaryenAtomicWait'](module, ptr, expected, timeout, Module['Type']['i64'], strToStack(name)));
       }
     }
   }
@@ -831,28 +836,28 @@ function wrapModule(module, self = {}) {
 
   self['i32'] = {
     'load'(offset, align, ptr, name) {
-      return preserveStack(() => Module['_BinaryenLoad'](module, 4, true, offset, align, Module['i32'], ptr, strToStack(name)));
+      return preserveStack(() => Module['_BinaryenLoad'](module, 4, true, offset, align, Module['Type']['i32'], ptr, strToStack(name)));
     },
     'load8_s'(offset, align, ptr, name) {
-      return preserveStack(() => Module['_BinaryenLoad'](module, 1, true, offset, align, Module['i32'], ptr, strToStack(name)));
+      return preserveStack(() => Module['_BinaryenLoad'](module, 1, true, offset, align, Module['Type']['i32'], ptr, strToStack(name)));
     },
     'load8_u'(offset, align, ptr, name) {
-      return preserveStack(() => Module['_BinaryenLoad'](module, 1, false, offset, align, Module['i32'], ptr, strToStack(name)));
+      return preserveStack(() => Module['_BinaryenLoad'](module, 1, false, offset, align, Module['Type']['i32'], ptr, strToStack(name)));
     },
     'load16_s'(offset, align, ptr, name) {
-      return preserveStack(() => Module['_BinaryenLoad'](module, 2, true, offset, align, Module['i32'], ptr, strToStack(name)));
+      return preserveStack(() => Module['_BinaryenLoad'](module, 2, true, offset, align, Module['Type']['i32'], ptr, strToStack(name)));
     },
     'load16_u'(offset, align, ptr, name) {
-      return preserveStack(() => Module['_BinaryenLoad'](module, 2, false, offset, align, Module['i32'], ptr, strToStack(name)));
+      return preserveStack(() => Module['_BinaryenLoad'](module, 2, false, offset, align, Module['Type']['i32'], ptr, strToStack(name)));
     },
     'store'(offset, align, ptr, value, name) {
-      return preserveStack(() => Module['_BinaryenStore'](module, 4, offset, align, ptr, value, Module['i32'], strToStack(name)));
+      return preserveStack(() => Module['_BinaryenStore'](module, 4, offset, align, ptr, value, Module['Type']['i32'], strToStack(name)));
     },
     'store8'(offset, align, ptr, value, name) {
-      return preserveStack(() => Module['_BinaryenStore'](module, 1, offset, align, ptr, value, Module['i32'], strToStack(name)));
+      return preserveStack(() => Module['_BinaryenStore'](module, 1, offset, align, ptr, value, Module['Type']['i32'], strToStack(name)));
     },
     'store16'(offset, align, ptr, value, name) {
-      return preserveStack(() => Module['_BinaryenStore'](module, 2, offset, align, ptr, value, Module['i32'], strToStack(name)));
+      return preserveStack(() => Module['_BinaryenStore'](module, 2, offset, align, ptr, value, Module['Type']['i32'], strToStack(name)));
     },
     'const'(x) {
       return preserveStack(() => {
@@ -994,152 +999,152 @@ function wrapModule(module, self = {}) {
     },
     'atomic': {
       'load'(offset, ptr, name, order) {
-        return preserveStack(() => Module['_BinaryenAtomicLoad'](module, 4, offset, Module['i32'], ptr, strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+        return preserveStack(() => Module['_BinaryenAtomicLoad'](module, 4, offset, Module['Type']['i32'], ptr, strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
       },
       'load8_u'(offset, ptr, name, order) {
-        return preserveStack(() => Module['_BinaryenAtomicLoad'](module, 1, offset, Module['i32'], ptr, strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+        return preserveStack(() => Module['_BinaryenAtomicLoad'](module, 1, offset, Module['Type']['i32'], ptr, strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
       },
       'load16_u'(offset, ptr, name) {
-        return preserveStack(() => Module['_BinaryenAtomicLoad'](module, 2, offset, Module['i32'], ptr, strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+        return preserveStack(() => Module['_BinaryenAtomicLoad'](module, 2, offset, Module['Type']['i32'], ptr, strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
       },
       'store'(offset, ptr, value, name, order) {
-        return preserveStack(() => Module['_BinaryenAtomicStore'](module, 4, offset, ptr, value, Module['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+        return preserveStack(() => Module['_BinaryenAtomicStore'](module, 4, offset, ptr, value, Module['Type']['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
       },
       'store8'(offset, ptr, value, name, order) {
-        return preserveStack(() => Module['_BinaryenAtomicStore'](module, 1, offset, ptr, value, Module['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+        return preserveStack(() => Module['_BinaryenAtomicStore'](module, 1, offset, ptr, value, Module['Type']['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
       },
       'store16'(offset, ptr, value, name, order) {
-        return preserveStack(() => Module['_BinaryenAtomicStore'](module, 2, offset, ptr, value, Module['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+        return preserveStack(() => Module['_BinaryenAtomicStore'](module, 2, offset, ptr, value, Module['Type']['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
       },
       'rmw': {
         'add'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAdd'], 4, offset, ptr, value, Module['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAdd'], 4, offset, ptr, value, Module['Type']['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'sub'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWSub'], 4, offset, ptr, value, Module['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWSub'], 4, offset, ptr, value, Module['Type']['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'and'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAnd'], 4, offset, ptr, value, Module['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAnd'], 4, offset, ptr, value, Module['Type']['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'or'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWOr'], 4, offset, ptr, value, Module['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWOr'], 4, offset, ptr, value, Module['Type']['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'xor'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXor'], 4, offset, ptr, value, Module['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXor'], 4, offset, ptr, value, Module['Type']['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'xchg'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXchg'], 4, offset, ptr, value, Module['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXchg'], 4, offset, ptr, value, Module['Type']['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'cmpxchg'(offset, ptr, expected, replacement, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicCmpxchg'](module, 4, offset, ptr, expected, replacement, Module['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicCmpxchg'](module, 4, offset, ptr, expected, replacement, Module['Type']['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
       },
       'rmw8_u': {
         'add'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAdd'], 1, offset, ptr, value, Module['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAdd'], 1, offset, ptr, value, Module['Type']['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'sub'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWSub'], 1, offset, ptr, value, Module['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWSub'], 1, offset, ptr, value, Module['Type']['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'and'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAnd'], 1, offset, ptr, value, Module['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAnd'], 1, offset, ptr, value, Module['Type']['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'or'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWOr'], 1, offset, ptr, value, Module['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWOr'], 1, offset, ptr, value, Module['Type']['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'xor'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXor'], 1, offset, ptr, value, Module['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXor'], 1, offset, ptr, value, Module['Type']['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'xchg'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXchg'], 1, offset, ptr, value, Module['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXchg'], 1, offset, ptr, value, Module['Type']['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'cmpxchg'(offset, ptr, expected, replacement, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicCmpxchg'](module, 1, offset, ptr, expected, replacement, Module['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicCmpxchg'](module, 1, offset, ptr, expected, replacement, Module['Type']['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
       },
       'rmw16_u': {
         'add'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAdd'], 2, offset, ptr, value, Module['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAdd'], 2, offset, ptr, value, Module['Type']['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'sub'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWSub'], 2, offset, ptr, value, Module['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWSub'], 2, offset, ptr, value, Module['Type']['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'and'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAnd'], 2, offset, ptr, value, Module['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAnd'], 2, offset, ptr, value, Module['Type']['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'or'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWOr'], 2, offset, ptr, value, Module['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWOr'], 2, offset, ptr, value, Module['Type']['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'xor'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXor'], 2, offset, ptr, value, Module['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXor'], 2, offset, ptr, value, Module['Type']['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'xchg'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXchg'], 2, offset, ptr, value, Module['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXchg'], 2, offset, ptr, value, Module['Type']['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'cmpxchg'(offset, ptr, expected, replacement, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicCmpxchg'](module, 2, offset, ptr, expected, replacement, Module['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicCmpxchg'](module, 2, offset, ptr, expected, replacement, Module['Type']['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
       },
     },
     'pop'() {
-      return Module['_BinaryenPop'](module, Module['i32']);
+      return Module['_BinaryenPop'](module, Module['Type']['i32']);
     }
   };
 
   self['i64'] = {
     'load'(offset, align, ptr, name) {
-      return preserveStack(() => Module['_BinaryenLoad'](module, 8, true, offset, align, Module['i64'], ptr, strToStack(name)));
+      return preserveStack(() => Module['_BinaryenLoad'](module, 8, true, offset, align, Module['Type']['i64'], ptr, strToStack(name)));
     },
     'load8_s'(offset, align, ptr, name) {
-      return preserveStack(() => Module['_BinaryenLoad'](module, 1, true, offset, align, Module['i64'], ptr, strToStack(name)));
+      return preserveStack(() => Module['_BinaryenLoad'](module, 1, true, offset, align, Module['Type']['i64'], ptr, strToStack(name)));
     },
     'load8_u'(offset, align, ptr, name) {
-      return preserveStack(() => Module['_BinaryenLoad'](module, 1, false, offset, align, Module['i64'], ptr, strToStack(name)));
+      return preserveStack(() => Module['_BinaryenLoad'](module, 1, false, offset, align, Module['Type']['i64'], ptr, strToStack(name)));
     },
     'load16_s'(offset, align, ptr, name) {
-      return preserveStack(() => Module['_BinaryenLoad'](module, 2, true, offset, align, Module['i64'], ptr, strToStack(name)));
+      return preserveStack(() => Module['_BinaryenLoad'](module, 2, true, offset, align, Module['Type']['i64'], ptr, strToStack(name)));
     },
     'load16_u'(offset, align, ptr, name) {
-      return preserveStack(() => Module['_BinaryenLoad'](module, 2, false, offset, align, Module['i64'], ptr, strToStack(name)));
+      return preserveStack(() => Module['_BinaryenLoad'](module, 2, false, offset, align, Module['Type']['i64'], ptr, strToStack(name)));
     },
     'load32_s'(offset, align, ptr, name) {
-      return preserveStack(() => Module['_BinaryenLoad'](module, 4, true, offset, align, Module['i64'], ptr, strToStack(name)));
+      return preserveStack(() => Module['_BinaryenLoad'](module, 4, true, offset, align, Module['Type']['i64'], ptr, strToStack(name)));
     },
     'load32_u'(offset, align, ptr, name) {
-      return preserveStack(() => Module['_BinaryenLoad'](module, 4, false, offset, align, Module['i64'], ptr, strToStack(name)));
+      return preserveStack(() => Module['_BinaryenLoad'](module, 4, false, offset, align, Module['Type']['i64'], ptr, strToStack(name)));
     },
     'store'(offset, align, ptr, value, name) {
-      return preserveStack(() => Module['_BinaryenStore'](module, 8, offset, align, ptr, value, Module['i64'], strToStack(name)));
+      return preserveStack(() => Module['_BinaryenStore'](module, 8, offset, align, ptr, value, Module['Type']['i64'], strToStack(name)));
     },
     'store8'(offset, align, ptr, value, name) {
-      return preserveStack(() => Module['_BinaryenStore'](module, 1, offset, align, ptr, value, Module['i64'], strToStack(name)));
+      return preserveStack(() => Module['_BinaryenStore'](module, 1, offset, align, ptr, value, Module['Type']['i64'], strToStack(name)));
     },
     'store16'(offset, align, ptr, value, name) {
-      return preserveStack(() => Module['_BinaryenStore'](module, 2, offset, align, ptr, value, Module['i64'], strToStack(name)));
+      return preserveStack(() => Module['_BinaryenStore'](module, 2, offset, align, ptr, value, Module['Type']['i64'], strToStack(name)));
     },
     'store32'(offset, align, ptr, value, name) {
-      return preserveStack(() => Module['_BinaryenStore'](module, 4, offset, align, ptr, value, Module['i64'], strToStack(name)));
+      return preserveStack(() => Module['_BinaryenStore'](module, 4, offset, align, ptr, value, Module['Type']['i64'], strToStack(name)));
     },
     'const'(x, y = undefined) {
       return preserveStack(() => {
@@ -1306,161 +1311,161 @@ function wrapModule(module, self = {}) {
     },
     'atomic': {
       'load'(offset, ptr, name, order) {
-        return preserveStack(() => Module['_BinaryenAtomicLoad'](module, 8, offset, Module['i64'], ptr, strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+        return preserveStack(() => Module['_BinaryenAtomicLoad'](module, 8, offset, Module['Type']['i64'], ptr, strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
       },
       'load8_u'(offset, ptr, name, order) {
-        return preserveStack(() => Module['_BinaryenAtomicLoad'](module, 1, offset, Module['i64'], ptr, strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+        return preserveStack(() => Module['_BinaryenAtomicLoad'](module, 1, offset, Module['Type']['i64'], ptr, strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
       },
       'load16_u'(offset, ptr, name, order) {
-        return preserveStack(() => Module['_BinaryenAtomicLoad'](module, 2, offset, Module['i64'], ptr, strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+        return preserveStack(() => Module['_BinaryenAtomicLoad'](module, 2, offset, Module['Type']['i64'], ptr, strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
       },
       'load32_u'(offset, ptr, name, order) {
-        return preserveStack(() => Module['_BinaryenAtomicLoad'](module, 4, offset, Module['i64'], ptr, strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+        return preserveStack(() => Module['_BinaryenAtomicLoad'](module, 4, offset, Module['Type']['i64'], ptr, strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
       },
       'store'(offset, ptr, value, name, order) {
-        return preserveStack(() => Module['_BinaryenAtomicStore'](module, 8, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+        return preserveStack(() => Module['_BinaryenAtomicStore'](module, 8, offset, ptr, value, Module['Type']['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
       },
       'store8'(offset, ptr, value, name, order) {
-        return preserveStack(() => Module['_BinaryenAtomicStore'](module, 1, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+        return preserveStack(() => Module['_BinaryenAtomicStore'](module, 1, offset, ptr, value, Module['Type']['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
       },
       'store16'(offset, ptr, value, name, order) {
-        return preserveStack(() => Module['_BinaryenAtomicStore'](module, 2, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+        return preserveStack(() => Module['_BinaryenAtomicStore'](module, 2, offset, ptr, value, Module['Type']['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
       },
       'store32'(offset, ptr, value, name, order) {
-        return preserveStack(() => Module['_BinaryenAtomicStore'](module, 4, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+        return preserveStack(() => Module['_BinaryenAtomicStore'](module, 4, offset, ptr, value, Module['Type']['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
       },
       'rmw': {
         'add'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAdd'], 8, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAdd'], 8, offset, ptr, value, Module['Type']['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'sub'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWSub'], 8, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWSub'], 8, offset, ptr, value, Module['Type']['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'and'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAnd'], 8, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAnd'], 8, offset, ptr, value, Module['Type']['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'or'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWOr'], 8, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWOr'], 8, offset, ptr, value, Module['Type']['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'xor'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXor'], 8, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXor'], 8, offset, ptr, value, Module['Type']['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'xchg'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXchg'], 8, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXchg'], 8, offset, ptr, value, Module['Type']['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'cmpxchg'(offset, ptr, expected, replacement, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicCmpxchg'](module, 8, offset, ptr, expected, replacement, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicCmpxchg'](module, 8, offset, ptr, expected, replacement, Module['Type']['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
       },
       'rmw8_u': {
         'add'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAdd'], 1, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAdd'], 1, offset, ptr, value, Module['Type']['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'sub'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWSub'], 1, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWSub'], 1, offset, ptr, value, Module['Type']['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'and'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAnd'], 1, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAnd'], 1, offset, ptr, value, Module['Type']['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'or'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWOr'], 1, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWOr'], 1, offset, ptr, value, Module['Type']['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'xor'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXor'], 1, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXor'], 1, offset, ptr, value, Module['Type']['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'xchg'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXchg'], 1, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXchg'], 1, offset, ptr, value, Module['Type']['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'cmpxchg'(offset, ptr, expected, replacement, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicCmpxchg'](module, 1, offset, ptr, expected, replacement, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicCmpxchg'](module, 1, offset, ptr, expected, replacement, Module['Type']['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
       },
       'rmw16_u': {
         'add'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAdd'], 2, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAdd'], 2, offset, ptr, value, Module['Type']['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'sub'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWSub'], 2, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWSub'], 2, offset, ptr, value, Module['Type']['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'and'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAnd'], 2, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAnd'], 2, offset, ptr, value, Module['Type']['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'or'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWOr'], 2, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWOr'], 2, offset, ptr, value, Module['Type']['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'xor'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXor'], 2, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXor'], 2, offset, ptr, value, Module['Type']['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'xchg'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXchg'], 2, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXchg'], 2, offset, ptr, value, Module['Type']['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'cmpxchg'(offset, ptr, expected, replacement, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicCmpxchg'](module, 2, offset, ptr, expected, replacement, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicCmpxchg'](module, 2, offset, ptr, expected, replacement, Module['Type']['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
       },
       'rmw32_u': {
         'add'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAdd'], 4, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAdd'], 4, offset, ptr, value, Module['Type']['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'sub'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWSub'], 4, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWSub'], 4, offset, ptr, value, Module['Type']['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'and'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAnd'], 4, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAnd'], 4, offset, ptr, value, Module['Type']['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'or'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWOr'], 4, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWOr'], 4, offset, ptr, value, Module['Type']['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'xor'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXor'], 4, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXor'], 4, offset, ptr, value, Module['Type']['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'xchg'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXchg'], 4, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXchg'], 4, offset, ptr, value, Module['Type']['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'cmpxchg'(offset, ptr, expected, replacement, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicCmpxchg'](module, 4, offset, ptr, expected, replacement, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicCmpxchg'](module, 4, offset, ptr, expected, replacement, Module['Type']['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
       },
     },
     'pop'() {
-      return Module['_BinaryenPop'](module, Module['i64']);
+      return Module['_BinaryenPop'](module, Module['Type']['i64']);
     }
   };
 
   self['f32'] = {
     'load'(offset, align, ptr, name) {
-      return preserveStack(() => Module['_BinaryenLoad'](module, 4, true, offset, align, Module['f32'], ptr, strToStack(name)));
+      return preserveStack(() => Module['_BinaryenLoad'](module, 4, true, offset, align, Module['Type']['f32'], ptr, strToStack(name)));
     },
     'store'(offset, align, ptr, value, name) {
-      return preserveStack(() => Module['_BinaryenStore'](module, 4, offset, align, ptr, value, Module['f32'], strToStack(name)));
+      return preserveStack(() => Module['_BinaryenStore'](module, 4, offset, align, ptr, value, Module['Type']['f32'], strToStack(name)));
     },
     'const'(x) {
       return preserveStack(() => {
@@ -1559,16 +1564,16 @@ function wrapModule(module, self = {}) {
       return Module['_BinaryenBinary'](module, Module['GeFloat32'], left, right);
     },
     'pop'() {
-      return Module['_BinaryenPop'](module, Module['f32']);
+      return Module['_BinaryenPop'](module, Module['Type']['f32']);
     }
   };
 
   self['f64'] = {
     'load'(offset, align, ptr, name) {
-      return preserveStack(() => Module['_BinaryenLoad'](module, 8, true, offset, align, Module['f64'], ptr, strToStack(name)));
+      return preserveStack(() => Module['_BinaryenLoad'](module, 8, true, offset, align, Module['Type']['f64'], ptr, strToStack(name)));
     },
     'store'(offset, align, ptr, value, name) {
-      return preserveStack(() => Module['_BinaryenStore'](module, 8, offset, align, ptr, value, Module['f64'], strToStack(name)));
+      return preserveStack(() => Module['_BinaryenStore'](module, 8, offset, align, ptr, value, Module['Type']['f64'], strToStack(name)));
     },
     'const'(x) {
       return preserveStack(() => {
@@ -1672,13 +1677,13 @@ function wrapModule(module, self = {}) {
       return Module['_BinaryenBinary'](module, Module['GeFloat64'], left, right);
     },
     'pop'() {
-      return Module['_BinaryenPop'](module, Module['f64']);
+      return Module['_BinaryenPop'](module, Module['Type']['f64']);
     }
   };
 
   self['v128'] = {
     'load'(offset, align, ptr, name) {
-      return preserveStack(() => Module['_BinaryenLoad'](module, 16, false, offset, align, Module['v128'], ptr, strToStack(name)));
+      return preserveStack(() => Module['_BinaryenLoad'](module, 16, false, offset, align, Module['Type']['v128'], ptr, strToStack(name)));
     },
     'load8_splat'(offset, align, ptr, name) {
       return preserveStack(() => Module['_BinaryenSIMDLoad'](module, Module['Load8SplatVec128'], offset, align, ptr, strToStack(name)));
@@ -1749,7 +1754,7 @@ function wrapModule(module, self = {}) {
         Module['_BinaryenSIMDLoadStoreLane'](module, Module['Store64LaneVec128'], offset, align, index, ptr, vec, strToStack(name)));
     },
     'store'(offset, align, ptr, value, name) {
-      return preserveStack(() => Module['_BinaryenStore'](module, 16, offset, align, ptr, value, Module['v128'], strToStack(name)));
+      return preserveStack(() => Module['_BinaryenStore'](module, 16, offset, align, ptr, value, Module['Type']['v128'], strToStack(name)));
     },
     'const'(i8s) {
       return preserveStack(() => {
@@ -1780,7 +1785,7 @@ function wrapModule(module, self = {}) {
       return Module['_BinaryenSIMDTernary'](module, Module['BitselectVec128'], left, right, cond);
     },
     'pop'() {
-      return Module['_BinaryenPop'](module, Module['v128']);
+      return Module['_BinaryenPop'](module, Module['Type']['v128']);
     }
   };
 
@@ -2422,49 +2427,49 @@ function wrapModule(module, self = {}) {
 
   self['funcref'] = {
     'pop'() {
-      return Module['_BinaryenPop'](module, Module['funcref']);
+      return Module['_BinaryenPop'](module, Module['Type']['funcref']);
     }
   };
 
   self['externref'] = {
     'pop'() {
-      return Module['_BinaryenPop'](module, Module['externref']);
+      return Module['_BinaryenPop'](module, Module['Type']['externref']);
     }
   };
 
   self['anyref'] = {
     'pop'() {
-      return Module['_BinaryenPop'](module, Module['anyref']);
+      return Module['_BinaryenPop'](module, Module['Type']['anyref']);
     }
   };
 
   self['eqref'] = {
     'pop'() {
-      return Module['_BinaryenPop'](module, Module['eqref']);
+      return Module['_BinaryenPop'](module, Module['Type']['eqref']);
     }
   };
 
   self['i31ref'] = {
     'pop'() {
-      return Module['_BinaryenPop'](module, Module['i31ref']);
+      return Module['_BinaryenPop'](module, Module['Type']['i31ref']);
     }
   };
 
   self['structref'] = {
     'pop'() {
-      return Module['_BinaryenPop'](module, Module['structref']);
+      return Module['_BinaryenPop'](module, Module['Type']['structref']);
     }
   };
 
   self['arrayref'] = {
     'pop'() {
-      return Module['_BinaryenPop'](module, Module['arrayref']);
+      return Module['_BinaryenPop'](module, Module['Type']['arrayref']);
     }
   };
 
   self['stringref'] = {
     'pop'() {
-      return Module['_BinaryenPop'](module, Module['stringref']);
+      return Module['_BinaryenPop'](module, Module['Type']['stringref']);
     }
   };
 
@@ -2583,11 +2588,11 @@ function wrapModule(module, self = {}) {
   };
 
   self['br_on_null'] = function(name, value) {
-    return preserveStack(() => Module['_BinaryenBrOn'](module, Module['BrOnNull'], strToStack(name), value, Module['unreachable']));
+    return preserveStack(() => Module['_BinaryenBrOn'](module, Module['BrOnNull'], strToStack(name), value, Module['Type']['unreachable']));
   };
 
   self['br_on_non_null'] = function(name, value) {
-    return preserveStack(() => Module['_BinaryenBrOn'](module, Module['BrOnNonNull'], strToStack(name), value, Module['unreachable']));
+    return preserveStack(() => Module['_BinaryenBrOn'](module, Module['BrOnNonNull'], strToStack(name), value, Module['Type']['unreachable']));
   };
 
   self['br_on_cast'] = function(name, value, castType) {
@@ -2627,6 +2632,10 @@ function wrapModule(module, self = {}) {
     }
   };
 
+  self['publish'] = function(ref) {
+    return Module['_BinaryenPublish'](module, ref);
+  };
+
   self['array'] = {
     'new'(type, size, init) {
       return Module['_BinaryenArrayNew'](module, type, size, init);
@@ -3236,11 +3245,11 @@ Module['getExpressionInfo'] = function(expr) {
   switch (id) {
     case Module['ConstId']:
       switch (type) {
-        case Module['i32']: info.value = Module['_BinaryenConstGetValueI32'](expr); break;
-        case Module['i64']: info.value = Module['_BinaryenConstGetValueI64'](expr); break;
-        case Module['f32']: info.value = Module['_BinaryenConstGetValueF32'](expr); break;
-        case Module['f64']: info.value = Module['_BinaryenConstGetValueF64'](expr); break;
-        case Module['v128']: {
+        case Module['Type']['i32']: info.value = Module['_BinaryenConstGetValueI32'](expr); break;
+        case Module['Type']['i64']: info.value = Module['_BinaryenConstGetValueI64'](expr); break;
+        case Module['Type']['f32']: info.value = Module['_BinaryenConstGetValueF32'](expr); break;
+        case Module['Type']['f64']: info.value = Module['_BinaryenConstGetValueF64'](expr); break;
+        case Module['Type']['v128']: {
           preserveStack(() => {
             const tempBuffer = stackAlloc(16);
             Module['_BinaryenConstGetValueV128'](expr, tempBuffer);
@@ -5012,6 +5021,15 @@ Module['WaitqueueNotify'] = makeExpressionWrapper(Module['_BinaryenWaitqueueNoti
   }
 });
 
+Module['Publish'] = makeExpressionWrapper(Module['_BinaryenPublishId'](), {
+  'getRef'(expr) {
+    return Module['_BinaryenPublishGetRef'](expr);
+  },
+  'setRef'(expr, refExpr) {
+    Module['_BinaryenPublishSetRef'](expr, refExpr);
+  }
+});
+
 Module['ArrayNew'] = makeExpressionWrapper(Module['_BinaryenArrayNewId'](), {
   'getInit'(expr) {
     return Module['_BinaryenArrayNewGetInit'](expr);
diff --git a/src/literal.h b/src/literal.h
index adb8e2f171e..335e117c147 100644
--- a/src/literal.h
+++ b/src/literal.h
@@ -19,6 +19,7 @@
 
 #include <array>
 #include <iostream>
+#include <variant>
 
 #include "support/bits.h"
 #include "support/hash.h"
@@ -212,7 +213,7 @@ class Literal {
     }
   }
 
-  static Literal makeFromMemory(void* p, Type type);
+  static Literal makeFromMemory(const void* p, Type type);
 
   static Literal makeSignedMin(Type type) {
     switch (type.getBasic()) {
@@ -312,6 +313,12 @@ class Literal {
   Name getFunc() const;
   std::shared_ptr<FuncData> getFuncData() const;
   std::shared_ptr<GCData> getGCData() const;
+  size_t getNumElements() const;
+  Literal getElement(size_t index, bool signed_ = false) const;
+  void setElement(size_t index, Literal value);
+  bool isRawBytes() const;
+  const std::vector<uint8_t>& getRawBytes() const;
+  std::vector<uint8_t>& getRawBytes();
   std::shared_ptr<ExnData> getExnData() const;
   std::shared_ptr<ContData> getContData() const;
 
@@ -784,28 +791,65 @@ std::ostream& operator<<(std::ostream& o, wasm::Literals literals);
 // A GC Struct, Array, or String is a set of values with a type saying how it
 // should be interpreted.
 struct GCData {
-  // The element or field values.
-  Literals values;
+  // The element or field values. Primitive numeric arrays use raw byte buffers
+  // (std::vector<uint8_t>), while reference arrays, structs, strings, and other
+  // reference allocations use Literals.
+  std::variant<std::vector<uint8_t>, Literals> storage;
 
   // The descriptor, if it exists, or null.
   Literal desc;
 
   GCData(Literals&& values,
          const Literal& desc = Literal::makeNull(HeapType::none))
-    : values(std::move(values)), desc(desc) {}
+    : storage(std::move(values)), desc(desc) {}
+
+  GCData(std::vector<uint8_t>&& data,
+         const Literal& desc = Literal::makeNull(HeapType::none))
+    : storage(std::move(data)), desc(desc) {}
+
+  bool isRawBytes() const {
+    return std::holds_alternative<std::vector<uint8_t>>(storage);
+  }
+
+  const std::vector<uint8_t>& getRawBytes() const {
+    return std::get<std::vector<uint8_t>>(storage);
+  }
+
+  std::vector<uint8_t>& getRawBytes() {
+    return std::get<std::vector<uint8_t>>(storage);
+  }
+
+  const Literals& getLiterals() const { return std::get<Literals>(storage); }
+
+  Literals& getLiterals() { return std::get<Literals>(storage); }
 };
 
+inline bool Literal::isRawBytes() const {
+  assert(isData());
+  return gcData->isRawBytes();
+}
+
+inline const std::vector<uint8_t>& Literal::getRawBytes() const {
+  assert(isData());
+  return gcData->getRawBytes();
+}
+
+inline std::vector<uint8_t>& Literal::getRawBytes() {
+  assert(isData());
+  return gcData->getRawBytes();
+}
+
 inline bool Literal::hasExternPayload() const {
   if (isNull()) {
     return false;
   }
   assert(type.getHeapType().isMaybeShared(HeapType::ext));
-  return gcData->values[0].type == Type::i32;
+  return gcData->getLiterals()[0].type == Type::i32;
 }
 
 inline int32_t Literal::getExternPayload() const {
   assert(hasExternPayload());
-  return gcData->values[0].geti32();
+  return gcData->getLiterals()[0].geti32();
 }
 
 } // namespace wasm
@@ -869,7 +913,7 @@ template<> struct hash<wasm::Literal> {
         return digest;
       }
       if (a.type.isString()) {
-        auto& values = a.getGCData()->values;
+        auto& values = a.getGCData()->getLiterals();
         wasm::rehash(digest, values.size());
         for (auto c : values) {
           wasm::rehash(digest, c.getInteger());
diff --git a/src/parser/contexts.h b/src/parser/contexts.h
index 6f0d38f9cd4..a0adea5708d 100644
--- a/src/parser/contexts.h
+++ b/src/parser/contexts.h
@@ -638,6 +638,7 @@ struct NullInstrParserCtx {
     return Ok{};
   }
   Result<> makePause(Index, const std::vector<Annotation>&) { return Ok{}; }
+  Result<> makePublish(Index, const std::vector<Annotation>&) { return Ok{}; }
   Result<> makeSIMDExtract(Index,
                            const std::vector<Annotation>&,
                            SIMDExtractOp,
@@ -2506,6 +2507,10 @@ struct ParseDefsCtx : TypeParserCtx<ParseDefsCtx>, AnnotationParserCtx {
     return withLoc(pos, irBuilder.makePause());
   }
 
+  Result<> makePublish(Index pos, const std::vector<Annotation>& annotations) {
+    return withLoc(pos, irBuilder.makePublish());
+  }
+
   Result<> makeSIMDExtract(Index pos,
                            const std::vector<Annotation>& annotations,
                            SIMDExtractOp op,
diff --git a/src/parser/parsers.h b/src/parser/parsers.h
index 090775647f7..2bf3acbf951 100644
--- a/src/parser/parsers.h
+++ b/src/parser/parsers.h
@@ -155,6 +155,8 @@ makeAtomicFence(Ctx&, Index, const std::vector<Annotation>&, MemoryOrder);
 template<typename Ctx>
 Result<> makePause(Ctx&, Index, const std::vector<Annotation>&);
 template<typename Ctx>
+Result<> makePublish(Ctx&, Index, const std::vector<Annotation>&);
+template<typename Ctx>
 Result<> makeSIMDExtract(
   Ctx&, Index, const std::vector<Annotation>&, SIMDExtractOp op, size_t lanes);
 template<typename Ctx>
@@ -1995,6 +1997,12 @@ makePause(Ctx& ctx, Index pos, const std::vector<Annotation>& annotations) {
   return ctx.makePause(pos, annotations);
 }
 
+template<typename Ctx>
+Result<>
+makePublish(Ctx& ctx, Index pos, const std::vector<Annotation>& annotations) {
+  return ctx.makePublish(pos, annotations);
+}
+
 template<typename Ctx>
 Result<> makeSIMDExtract(Ctx& ctx,
                          Index pos,
diff --git a/src/passes/CMakeLists.txt b/src/passes/CMakeLists.txt
index 41ccdef82bd..ab08d3a410b 100644
--- a/src/passes/CMakeLists.txt
+++ b/src/passes/CMakeLists.txt
@@ -110,6 +110,7 @@ set(passes_SOURCES
   TraceCalls.cpp
   RandomizeBranchHints.cpp
   RedundantSetElimination.cpp
+  RemoveEmptyFunctionExports.cpp
   RemoveExports.cpp
   RemoveImports.cpp
   RemoveMemoryInit.cpp
@@ -124,7 +125,6 @@ set(passes_SOURCES
   ReorderLocals.cpp
   ReorderTypes.cpp
   ReReloop.cpp
-  TrapMode.cpp
   TypeGeneralizing.cpp
   TypeRefining.cpp
   TypeMerging.cpp
@@ -138,6 +138,7 @@ set(passes_SOURCES
   StackCheck.cpp
   StripEH.cpp
   SSAify.cpp
+  TailCall.cpp
   TupleOptimization.cpp
   TranslateEH.cpp
   TypeFinalizing.cpp
diff --git a/src/passes/ConstraintAnalysis.cpp b/src/passes/ConstraintAnalysis.cpp
index fff4e4b8ed3..9e275665e9e 100644
--- a/src/passes/ConstraintAnalysis.cpp
+++ b/src/passes/ConstraintAnalysis.cpp
@@ -66,6 +66,8 @@
 // function analysis).
 //
 
+#include <algorithm>
+
 #include "cfg/cfg-traversal.h"
 #include "ir/constraint.h"
 #include "ir/drop.h"
@@ -146,11 +148,12 @@ struct ConstraintAnalysis
 
   void maybeMarkRelevant(Expression* curr) {
     // If this parses into a constraint on a local, that local is relevant.
-    if (auto parsed = LocalConstraint::parseCondition(curr);
-        parsed && isRelevantType(getFunction()->getLocalType(parsed->local))) {
-      relevantLocals[parsed->local] = true;
-      if (auto* other = std::get_if<Index>(&parsed->constraint.term)) {
-        relevantLocals[*other] = true;
+    for (auto& pair : ParsedAndedConstraints::parseCondition(curr)) {
+      if (isRelevantType(getFunction()->getLocalType(pair.local))) {
+        relevantLocals[pair.local] = true;
+        if (auto* other = std::get_if<Index>(&pair.constraint.term)) {
+          relevantLocals[*other] = true;
+        }
       }
     }
   }
@@ -371,9 +374,9 @@ struct ConstraintAnalysis
         // Find the constraints sent to this specific successor, if there is a
         // branch, and use them.
         if (auto branch = getBranchConstraints(block, out);
-            branch && checkRelevancy(*branch)) {
+            filterRelevant(branch), !branch.empty()) {
           auto sentConstraints = constraints;
-          applyBranchConstraints(*branch, sentConstraints);
+          applyBranchConstraints(branch, sentConstraints);
 #if CONSTRAINT_DEBUG
           std::cout << block << " sending branch to " << out
                     << " with sent constraints: " << sentConstraints << '\n';
@@ -441,6 +444,9 @@ struct ConstraintAnalysis
   void optimizeExpression(Expression** currp,
                           const BasicBlockConstraintMap& constraints) {
     auto* curr = *currp;
+    // Note that we don't need to try to parse a series of constraints with
+    // ParsedAndedConstraints: if there is a tree of ANDed things, we will
+    // simply optimize it as we walk it, each time handling one.
     auto parsed = LocalConstraint::parse(curr);
     if (!parsed) {
       return;
@@ -472,8 +478,8 @@ struct ConstraintAnalysis
 
   // Given a predecessor and one of its successors, find new constraints that
   // can be added due to the flow to that specific successor.
-  std::optional<LocalConstraint> getBranchConstraints(BasicBlock* pred,
-                                                      BasicBlock* succ) {
+  ParsedAndedConstraints getBranchConstraints(BasicBlock* pred,
+                                              BasicBlock* succ) {
     auto* brancher = pred->contents.brancher;
     if (!brancher) {
       return {};
@@ -502,32 +508,31 @@ struct ConstraintAnalysis
     return {};
   }
 
-  std::optional<LocalConstraint> getConstraintsFromIf(If* iff,
-                                                      bool physicalSuccessor) {
-    auto parsed = LocalConstraint::parseCondition(iff->condition);
-    if (parsed && !physicalSuccessor) {
+  ParsedAndedConstraints getConstraintsFromIf(If* iff, bool physicalSuccessor) {
+    auto parsed = ParsedAndedConstraints::parseCondition(iff->condition);
+    if (!physicalSuccessor) {
       // We are in the ifFalse, so negate the condition.
-      parsed->constraint = parsed->constraint.negate();
+      parsed.negate();
     }
     return parsed;
   }
 
-  std::optional<LocalConstraint>
-  getConstraintsFromBreak(Break* br, bool physicalSuccessor) {
+  ParsedAndedConstraints getConstraintsFromBreak(Break* br,
+                                                 bool physicalSuccessor) {
     // We get here when there is more than one successor, so there must be a
     // condition.
     assert(br->condition);
 
-    auto parsed = LocalConstraint::parseCondition(br->condition);
-    if (parsed && physicalSuccessor) {
+    auto parsed = ParsedAndedConstraints::parseCondition(br->condition);
+    if (physicalSuccessor) {
       // The branch was not taken, so negate the condition.
-      parsed->constraint = parsed->constraint.negate();
+      parsed.negate();
     }
     return parsed;
   }
 
-  std::optional<LocalConstraint>
-  getConstraintsFromBrOn(BrOn* brOn, bool physicalSuccessor) {
+  ParsedAndedConstraints getConstraintsFromBrOn(BrOn* brOn,
+                                                bool physicalSuccessor) {
     // The constraint on that local depends on the op.
     // TODO: Handle BrOnCast* etc using subtyping operations.
     if (brOn->op != BrOnNull && brOn->op != BrOnNonNull) {
@@ -537,10 +542,10 @@ struct ConstraintAnalysis
     // parseCondition can parse more things than a local.get, which is all we
     // handle here, but there is no other valid IR that can appear there, so we
     // can reuse it.
-    auto parsed = LocalConstraint::parseCondition(brOn->ref);
+    auto parsed = ParsedAndedConstraints::parseCondition(brOn->ref);
     // Negate depending on the op and (similar to Break) the successor.
-    if (parsed && ((brOn->op == BrOnNull) ^ physicalSuccessor)) {
-      parsed->constraint = parsed->constraint.negate();
+    if ((brOn->op == BrOnNull) ^ physicalSuccessor) {
+      parsed.negate();
     }
     return parsed;
   }
@@ -568,14 +573,6 @@ struct ConstraintAnalysis
         return;
       }
 
-      // See above on binary action counting limits.
-      if (auto* binary = set->value->dynCast<Binary>()) {
-        if (binaryActionCounts[binary]++ >= MaxBinaryActions) {
-          constraints.setProvesNothing(set->index);
-          return;
-        }
-      }
-
       // Look at the fallthrough. It is valid to do so, because our constraints
       // only track two things, constants and locals. For a constant, it does
       // not change while falling through. For a local, the only way for the
@@ -600,8 +597,47 @@ struct ConstraintAnalysis
       // opportunity to write any other value while falling through. (And, any
       // local.tee appearing here would have been reached earlier in the
       // traversal, and handled.)
-      auto* value =
-        Properties::getFallthrough(set->value, getPassOptions(), *getModule());
+      auto* value = set->value;
+      while (1) {
+        if (value->is<LocalSet>()) {
+          // We stop at the first tee: we don't need to look any further, and
+          // will just apply that local's values to ourselves, saving repeated
+          // work.
+          break;
+        }
+        auto* next = Properties::getImmediateFallthrough(
+          value, getPassOptions(), *getModule());
+        if (value == next) {
+          break;
+        } else {
+          value = next;
+        }
+      }
+
+      // Now that we know the value, check binary action counting limits (see
+      // above).
+      if (auto* binary = value->dynCast<Binary>()) {
+        // The code below will stop calculating this binary once we pass
+        // MaxBinaryActions operations on it. That is enough to prevent
+        // unbounded work on this binary, however, we may end up reaching this
+        // basic block an even larger number of times for other reasons, i.e.,
+        // just because of a very complex CFG. That should be very rare, but can
+        // happen. In debug builds we check we do not exceed a very high limit
+        // there, intending to throw an assert rather than just hang in the case
+        // of a bug (as assert is easier to diagnose, even if it happens after a
+        // long delay).
+        auto& count = binaryActionCounts[binary];
+#ifndef NDEBUG
+        static const Index MaxBasicBlockActions = 1024 * 1024;
+        assert(count < MaxBasicBlockActions);
+#endif
+        count++;
+        if (count >= MaxBinaryActions) {
+          constraints.setProvesNothing(set->index);
+          return;
+        }
+      }
+
       constraints.set(set->index, value);
     }
   }
@@ -633,17 +669,31 @@ struct ConstraintAnalysis
     return true;
   }
 
+  // Filters out constraints on irrelevant locals.
+  void filterRelevant(ParsedAndedConstraints& parsed) {
+    parsed.erase(std::remove_if(parsed.begin(),
+                                parsed.end(),
+                                [&](const LocalConstraint& pair) {
+                                  return !checkRelevancy(pair);
+                                }),
+                 parsed.end());
+  }
+
   // Apply branch constraints to the current set of constraints.
-  void applyBranchConstraints(const LocalConstraint& branch,
+  void applyBranchConstraints(const ParsedAndedConstraints& branch,
                               BasicBlockConstraintMap& constraints) {
-    // Extend the range of values in the "jump ahead" manner described in the
-    // top-level comment.
-    if (applyBranchRangeExtensionToConstraints(branch, constraints)) {
-      return;
-    }
+    for (auto& pair : branch) {
+      // Extend the range of values in the "jump ahead" manner described in the
+      // top-level comment.
+      if (!applyBranchRangeExtensionToConstraints(pair, constraints)) {
+        // Otherwise, apply the constraint normally.
+        constraints.approximateAnd(pair.local, pair.constraint);
+      }
 
-    // Otherwise, apply the constraint normally.
-    constraints.approximateAnd(branch.local, branch.constraint);
+      if (constraints.unreachable) {
+        return;
+      }
+    }
   }
 
   bool
diff --git a/src/passes/DeadArgumentElimination2.cpp b/src/passes/DeadArgumentElimination2.cpp
index 4793789373a..4597ae76ef5 100644
--- a/src/passes/DeadArgumentElimination2.cpp
+++ b/src/passes/DeadArgumentElimination2.cpp
@@ -158,7 +158,7 @@ struct FunctionInfo {
   std::unordered_map<HeapType, ParamLocations> forwardedToIndirectParams;
 
   // Locations forwarded to this function's result. These locations will become
-  // used if the result turns out ot be used.
+  // used if the result turns out to be used.
   std::vector<Location> resultSources;
 
   // For each parameter of this function, the list of locations that will become
diff --git a/src/passes/GlobalEffects.cpp b/src/passes/GlobalEffects.cpp
index f3313700e8e..e4e95a833f4 100644
--- a/src/passes/GlobalEffects.cpp
+++ b/src/passes/GlobalEffects.cpp
@@ -138,10 +138,12 @@ std::map<Function*, FuncInfo> analyzeFuncs(Module& module,
         // below.
         funcInfo.effects->calls = false;
 
-        // Clear throws as well, as we are "forgetting" calls right now, and
-        // want to forget their throwing effect as well. If we see something
-        // else that throws, below, then we'll note that there.
+        // Clear throws and suspends as well, as we are "forgetting" calls right
+        // now, and want to forget their throwing and suspending effects as
+        // well. If we see something else that throws or suspends, below, then
+        // we'll note that there.
         funcInfo.effects->throws_ = false;
+        funcInfo.effects->suspends = false;
 
         struct CallScanner
           : public PostWalker<CallScanner,
@@ -179,12 +181,16 @@ std::map<Function*, FuncInfo> analyzeFuncs(Module& module,
               assert(options.worldMode == WorldMode::Open);
               funcInfo.effects = std::nullopt;
             } else {
-              // No call here, but update throwing if we see it. (Only do so,
-              // however, if we have effects; if we cleared it - see before -
-              // then we assume the worst anyhow, and have nothing to update.)
+              // No call here, but update throwing and suspending if we see it.
+              // (Only do so, however, if we have effects; if we cleared it -
+              // see before - then we assume the worst anyhow, and have nothing
+              // to update.)
               if (effects.throws_ && funcInfo.effects) {
                 funcInfo.effects->throws_ = true;
               }
+              if (effects.suspends && funcInfo.effects) {
+                funcInfo.effects->suspends = true;
+              }
             }
           }
         };
diff --git a/src/passes/GlobalTypeOptimization.cpp b/src/passes/GlobalTypeOptimization.cpp
index 46eb698eaa4..b0bb31edbd9 100644
--- a/src/passes/GlobalTypeOptimization.cpp
+++ b/src/passes/GlobalTypeOptimization.cpp
@@ -70,16 +70,20 @@ struct FieldInfo {
 
 struct FieldInfoScanner
   : public StructUtils::StructScanner<FieldInfo, FieldInfoScanner> {
+  std::unordered_map<Function*, std::vector<Type>>& jsExposedTypes;
+
   std::unique_ptr<Pass> create() override {
-    return std::make_unique<FieldInfoScanner>(functionNewInfos,
-                                              functionSetGetInfos);
+    return std::make_unique<FieldInfoScanner>(
+      functionNewInfos, functionSetGetInfos, jsExposedTypes);
   }
 
   FieldInfoScanner(
     StructUtils::FunctionStructValuesMap<FieldInfo>& functionNewInfos,
-    StructUtils::FunctionStructValuesMap<FieldInfo>& functionSetGetInfos)
+    StructUtils::FunctionStructValuesMap<FieldInfo>& functionSetGetInfos,
+    std::unordered_map<Function*, std::vector<Type>>& jsExposedTypes)
     : StructUtils::StructScanner<FieldInfo, FieldInfoScanner>(
-        functionNewInfos, functionSetGetInfos) {}
+        functionNewInfos, functionSetGetInfos),
+      jsExposedTypes(jsExposedTypes) {}
 
   void noteExpression(Expression* expr,
                       HeapType type,
@@ -116,16 +120,8 @@ struct FieldInfoScanner
   // Converting a reference to externref makes the prototype field on its
   // descriptor available to be read by JS, if such a field exists.
   void visitRefAs(RefAs* curr) {
-    if (curr->op != ExternConvertAny) {
-      return;
-    }
-    if (!curr->value->type.isRef()) {
-      return;
-    }
-    if (auto desc = curr->value->type.getHeapType().getDescriptorType();
-        desc && JSUtils::hasPossibleJSPrototypeField(*desc)) {
-      auto exact = curr->value->type.getExactness();
-      functionSetGetInfos[getFunction()][{*desc, exact}][0].noteRead();
+    if (curr->op == ExternConvertAny && curr->value->type.isRef()) {
+      jsExposedTypes.at(getFunction()).push_back(curr->value->type);
     }
   }
 };
@@ -139,6 +135,11 @@ struct GlobalTypeOptimization : public Pass {
   // rare).
   std::unordered_map<HeapType, std::vector<bool>> canBecomeImmutable;
 
+  // Descriptor types that are exposed to JS but do _not_ configure prototypes
+  // for their described types. We must avoid optimizing these types such that
+  // they start configuring prototypes.
+  std::unordered_set<HeapType> exposedNoProtoDescs;
+
   // Maps each field to its new index after field removals. That is, this
   // takes into account that fields before this one may have been removed,
   // which would then reduce this field's index. If a field itself is removed,
@@ -149,6 +150,32 @@ struct GlobalTypeOptimization : public Pass {
   static const Index RemovedField = Index(-1);
   std::unordered_map<HeapType, std::vector<Index>> indexesAfterRemovals;
 
+  struct IndexAnalysis {
+    // The size after removing fields and possibly adding a placeholder.
+    Index newSize = 0;
+    bool hasPlaceholder = false;
+
+    // `indexes` is the mapping from old to new indices.
+    IndexAnalysis(const std::vector<Index>& indexes) {
+      Index maxIndex = 0;
+      bool hasKept = false;
+      bool hasIndexZero = false;
+      for (auto idx : indexes) {
+        if (idx != RemovedField) {
+          hasKept = true;
+          maxIndex = std::max(maxIndex, idx);
+          if (idx == 0) {
+            hasIndexZero = true;
+          }
+        }
+      }
+      newSize = hasKept ? maxIndex + 1 : 0;
+      // We know there is a placeholder if we have fields but none of them are
+      // at index 0.
+      hasPlaceholder = hasKept && !hasIndexZero;
+    }
+  };
+
   void run(Module* module) override {
     if (!module->features.hasGC()) {
       return;
@@ -157,21 +184,32 @@ struct GlobalTypeOptimization : public Pass {
       Fatal() << "GTO requires --closed-world";
     }
 
+    std::unordered_map<Function*, std::vector<Type>> jsExposedTypesByFunction;
+    jsExposedTypesByFunction[nullptr];
+    for (auto& func : module->functions) {
+      jsExposedTypesByFunction[func.get()];
+    }
+
     // Find and analyze struct operations inside each function.
     StructUtils::FunctionStructValuesMap<FieldInfo> functionNewInfos(*module),
       functionSetGetInfos(*module);
-    FieldInfoScanner scanner(functionNewInfos, functionSetGetInfos);
+    FieldInfoScanner scanner(
+      functionNewInfos, functionSetGetInfos, jsExposedTypesByFunction);
     scanner.run(getPassRunner(), module);
     scanner.runOnModuleCode(getPassRunner(), module);
 
     // Combine the data from the functions.
     functionSetGetInfos.combineInto(combinedSetGetInfos);
+    std::vector<Type> jsExposedTypes;
+    for (auto& [_, types] : jsExposedTypesByFunction) {
+      jsExposedTypes.insert(jsExposedTypes.end(), types.begin(), types.end());
+    }
 
     SubTypes subTypes(*module);
 
     // Analyze the JS interface to find fields holding configured prototypes
     // that cannot be removed.
-    analyzeJSInterface(*module, subTypes);
+    analyzeJSInterface(*module, subTypes, jsExposedTypes);
 
     // Propagate information to super and subtypes on set/get infos:
     //
@@ -291,15 +329,18 @@ struct GlobalTypeOptimization : public Pass {
       }
 
       // We need to compute the new set of indexes if we are removing fields, or
-      // if our parent removed fields. In the latter case, our parent may have
-      // reordered fields even if we ourselves are not removing anything, and we
-      // must update to match the parent's order.
+      // if our parent removed fields, or if we might need a placeholder because
+      // this type is exposed outside the module and does not configure a JS
+      // prototype. If we have a parent, it may have reordered fields even if we
+      // ourselves are not removing anything, and we must update to match the
+      // parent's order.
       auto super = type.getDeclaredSuperType();
       auto superHasUpdates = super && indexesAfterRemovals.contains(*super);
-      if (!removableIndexes.empty() || superHasUpdates) {
-        // We are removing fields. Reorder them to allow that, as in the general
-        // case we can only remove fields from the end, so that if our subtypes
-        // still need the fields they can append them. For example:
+      bool isExposedNoProto = exposedNoProtoDescs.contains(type);
+      if (!removableIndexes.empty() || superHasUpdates || isExposedNoProto) {
+        // We might be removing fields. Reorder them to allow that, as in the
+        // general case we can only remove fields from the end, so that if our
+        // subtypes still need the fields they can append them. For example:
         //
         //  type A     = { x: i32, y: f64 };
         //  type B : A = { x: 132, y: f64, z: v128 };
@@ -392,6 +433,38 @@ struct GlobalTypeOptimization : public Pass {
           }
         }
 
+        // If the type has no supertype (or its supertype has no fields), check
+        // if its first field becomes prototype-exposing. If so, add a
+        // placeholder at index 0 and shift all computed indices.
+        if (isExposedNoProto && (!super || super->getStruct().fields.empty())) {
+          // Find the field that will become field 0.
+          Index i = 0;
+          for (; i < fields.size(); ++i) {
+            if (indexesAfterRemoval[i] == 0) {
+              break;
+            }
+          }
+          // Check whether that field would expose a prototype.
+          if (i < fields.size()) {
+            Field optimizedField = fields[i];
+            if (auto it = canBecomeImmutable.find(type);
+                it != canBecomeImmutable.end() && i < it->second.size() &&
+                it->second[i]) {
+              optimizedField.mutable_ = Immutable;
+            }
+            if (JSUtils::isPossibleJSPrototypeField(optimizedField)) {
+              // The field exposes a prototype. Increment all field indices to
+              // make room for a placeholder first field (which will be
+              // materialized as an i8 field later).
+              for (auto& idx : indexesAfterRemoval) {
+                if (idx != RemovedField) {
+                  ++idx;
+                }
+              }
+            }
+          }
+        }
+
         // Only store the new indexes we computed if we found something
         // interesting. We might not, if e.g. our parent removes fields and we
         // add them back in the exact order we started with. In such cases,
@@ -416,7 +489,9 @@ struct GlobalTypeOptimization : public Pass {
     }
   }
 
-  void analyzeJSInterface(Module& wasm, const SubTypes& subTypes) {
+  void analyzeJSInterface(Module& wasm,
+                          const SubTypes& subTypes,
+                          const std::vector<Type>& jsExposedTypes) {
     if (!wasm.features.hasCustomDescriptors()) {
       return;
     }
@@ -426,10 +501,16 @@ struct GlobalTypeOptimization : public Pass {
     // Mark the relevant prototype field as read and return true iff we newly
     // know we have to propagate the exposure to subtypes.
     auto noteExposed = [&](HeapType type, Exactness exact = Inexact) -> bool {
-      if (auto desc = type.getDescriptorType();
-          desc && JSUtils::hasPossibleJSPrototypeField(*desc)) {
-        // This field holds a JS-visible prototype. Do not remove it.
-        combinedSetGetInfos[std::make_pair(*desc, exact)][0].noteRead();
+      if (auto desc = type.getDescriptorType()) {
+        if (JSUtils::hasPossibleJSPrototypeField(*desc)) {
+          // This descriptor configures a JS-visible prototype. Do not remove
+          // it.
+          combinedSetGetInfos[std::make_pair(*desc, exact)][0].noteRead();
+        } else {
+          // This descriptor does _not_ configure a JS prototype. Do not add
+          // one.
+          exposedNoProtoDescs.insert(*desc);
+        }
       }
       if (exact == Inexact) {
         return subtypesExposed.insert(type).second;
@@ -449,6 +530,12 @@ struct GlobalTypeOptimization : public Pass {
 
     JSUtils::iterJSInterface(wasm, flowIn, flowOut);
 
+    for (auto type : jsExposedTypes) {
+      if (type.isRef()) {
+        noteExposed(type.getHeapType(), type.getExactness());
+      }
+    }
+
     // Any type that is a subtype of an exposed type is also exposed. Propagate
     // from supertypes to subtypes.
     std::vector<HeapType> work(subtypesExposed.begin(), subtypesExposed.end());
@@ -471,6 +558,20 @@ struct GlobalTypeOptimization : public Pass {
         }
       }
     }
+
+    // Also propagate lack of exposed descriptors to supertypes so that
+    // descriptor hierarchies have consistent layouts. Do not propagate to
+    // supertypes that actually expose a prototype, which can happen when the
+    // subtype has refined an externref field to a nullexternref.
+    for (auto type : subTypes.types) {
+      if (exposedNoProtoDescs.contains(type)) {
+        auto curr = type.getDeclaredSuperType();
+        while (curr && !JSUtils::hasPossibleJSPrototypeField(*curr)) {
+          exposedNoProtoDescs.insert(*curr);
+          curr = curr->getDeclaredSuperType();
+        }
+      }
+    }
   }
 
   void updateTypes(Module& wasm) {
@@ -499,17 +600,19 @@ struct GlobalTypeOptimization : public Pass {
         auto remIter = parent.indexesAfterRemovals.find(oldStructType);
         if (remIter != parent.indexesAfterRemovals.end()) {
           auto& indexesAfterRemoval = remIter->second;
-          Index removed = 0;
+          IndexAnalysis analysis(indexesAfterRemoval);
           auto copy = newFields;
-          for (Index i = 0; i < newFields.size(); i++) {
+          newFields.resize(analysis.newSize);
+          if (analysis.hasPlaceholder) {
+            newFields[0] = Field(Field::i8, Immutable);
+          }
+          for (Index i = 0; i < copy.size(); i++) {
             auto newIndex = indexesAfterRemoval[i];
             if (newIndex != RemovedField) {
+              assert(newIndex < newFields.size());
               newFields[newIndex] = copy[i];
-            } else {
-              removed++;
             }
           }
-          newFields.resize(newFields.size() - removed);
 
           // Update field names as well. The Type Rewriter cannot do this for
           // us, as it does not know which old fields map to which new ones (it
@@ -540,8 +643,26 @@ struct GlobalTypeOptimization : public Pass {
     TypeRewriter(wasm, *this).update();
   }
 
+  Index getNewIndex(HeapType type, Index index) {
+    auto iter = indexesAfterRemovals.find(type);
+    if (iter == indexesAfterRemovals.end()) {
+      return index;
+    }
+    auto& indexesAfterRemoval = iter->second;
+    auto newIndex = indexesAfterRemoval[index];
+    assert(newIndex < IndexAnalysis(indexesAfterRemoval).newSize ||
+           newIndex == RemovedField);
+    return newIndex;
+  }
+
   // After updating the types to remove certain fields, we must also remove
-  // them from struct instructions.
+  // them from struct instructions and update field indices. We do this in two
+  // passes: first FieldRemover removes/reorders StructNew operands and replaces
+  // removed StructSets (which invokes EffectAnalyzer via ChildLocalizer and
+  // getResultOfFirst), and then IndexUpdater updates the field indices on
+  // remaining struct instructions. Keeping the old indices during FieldRemover
+  // is essential because EffectAnalyzer inspects type.getStruct().fields[index]
+  // on the old HeapTypes, which requires old indices.
   void updateInstructions(Module& wasm) {
     struct FieldRemover : public WalkerPass<PostWalker<FieldRemover>> {
       bool isFunctionParallel() override { return true; }
@@ -595,26 +716,31 @@ struct GlobalTypeOptimization : public Pass {
         auto& operands = curr->operands;
         assert(indexesAfterRemoval.size() == operands.size());
 
-        Index removed = 0;
+        IndexAnalysis analysis(indexesAfterRemoval);
         std::vector<Expression*> old(operands.begin(), operands.end());
         for (Index i = 0; i < operands.size(); ++i) {
-          auto newIndex = indexesAfterRemoval[i];
-          if (newIndex != RemovedField) {
-            assert(newIndex < operands.size());
-            operands[newIndex] = old[i];
-          } else {
-            ++removed;
+          if (indexesAfterRemoval[i] == RemovedField) {
             if (!func &&
                 EffectAnalyzer(getPassOptions(), *getModule(), old[i]).trap) {
               removedTrappingInits.push_back(old[i]);
             }
           }
         }
-        if (removed) {
-          operands.resize(operands.size() - removed);
-        } else {
-          // If we didn't remove anything then we must have reordered (or else
-          // we have done pointless work).
+        operands.resize(analysis.newSize);
+        if (analysis.hasPlaceholder) {
+          // The value we put in the i8 placeholder does not matter.
+          operands[0] = Builder(*getModule()).makeConst(Literal(int32_t(0)));
+        }
+        for (Index i = 0; i < old.size(); ++i) {
+          auto newIndex = indexesAfterRemoval[i];
+          if (newIndex != RemovedField) {
+            assert(newIndex < operands.size());
+            operands[newIndex] = old[i];
+          }
+        }
+        if (analysis.newSize == old.size() && !analysis.hasPlaceholder) {
+          // If we didn't remove or insert anything then we must have reordered
+          // (or else we have done pointless work).
           assert(indexesAfterRemoval !=
                  makeIdentity(indexesAfterRemoval.size()));
         }
@@ -625,11 +751,9 @@ struct GlobalTypeOptimization : public Pass {
           return;
         }
 
-        auto newIndex = getNewIndex(curr->ref->type.getHeapType(), curr->index);
-        if (newIndex != RemovedField) {
-          // Map to the new index.
-          curr->index = newIndex;
-        } else {
+        auto newIndex =
+          parent.getNewIndex(curr->ref->type.getHeapType(), curr->index);
+        if (newIndex == RemovedField) {
           // This field was removed, so just emit drops of our children, plus a
           // trap if the ref is null. Note that we must preserve the order of
           // operations here: the trap on a null ref happens after the value,
@@ -650,12 +774,42 @@ struct GlobalTypeOptimization : public Pass {
         }
       }
 
+      void visitFunction(Function* curr) {
+        if (needEHFixups) {
+          EHUtils::handleBlockNestedPops(curr, *getModule());
+        }
+      }
+    };
+
+    struct IndexUpdater : public WalkerPass<PostWalker<IndexUpdater>> {
+      bool isFunctionParallel() override { return true; }
+
+      GlobalTypeOptimization& parent;
+
+      IndexUpdater(GlobalTypeOptimization& parent) : parent(parent) {}
+
+      std::unique_ptr<Pass> create() override {
+        return std::make_unique<IndexUpdater>(parent);
+      }
+
+      void visitStructSet(StructSet* curr) {
+        if (curr->ref->type == Type::unreachable) {
+          return;
+        }
+
+        auto newIndex =
+          parent.getNewIndex(curr->ref->type.getHeapType(), curr->index);
+        assert(newIndex != RemovedField);
+        curr->index = newIndex;
+      }
+
       void visitStructGet(StructGet* curr) {
         if (curr->ref->type == Type::unreachable) {
           return;
         }
 
-        auto newIndex = getNewIndex(curr->ref->type.getHeapType(), curr->index);
+        auto newIndex =
+          parent.getNewIndex(curr->ref->type.getHeapType(), curr->index);
         // We must not remove a field that is read from.
         assert(newIndex != RemovedField);
         curr->index = newIndex;
@@ -666,7 +820,8 @@ struct GlobalTypeOptimization : public Pass {
           return;
         }
 
-        auto newIndex = getNewIndex(curr->ref->type.getHeapType(), curr->index);
+        auto newIndex =
+          parent.getNewIndex(curr->ref->type.getHeapType(), curr->index);
         // We must not remove a field that is read from.
         assert(newIndex != RemovedField);
         curr->index = newIndex;
@@ -677,45 +832,36 @@ struct GlobalTypeOptimization : public Pass {
           return;
         }
 
-        auto newIndex = getNewIndex(curr->ref->type.getHeapType(), curr->index);
+        auto newIndex =
+          parent.getNewIndex(curr->ref->type.getHeapType(), curr->index);
         // We must not remove a field that is read from.
         assert(newIndex != RemovedField);
         curr->index = newIndex;
       }
 
-      void visitFunction(Function* curr) {
-        if (needEHFixups) {
-          EHUtils::handleBlockNestedPops(curr, *getModule());
-        }
-      }
-
-    private:
-      Index getNewIndex(HeapType type, Index index) {
-        auto iter = parent.indexesAfterRemovals.find(type);
-        if (iter == parent.indexesAfterRemovals.end()) {
-          return index;
-        }
-        auto& indexesAfterRemoval = iter->second;
-        auto newIndex = indexesAfterRemoval[index];
-        assert(newIndex < indexesAfterRemoval.size() ||
-               newIndex == RemovedField);
-        return newIndex;
-      }
+      // TODO: visitStructWait
     };
 
-    FieldRemover remover(*this);
-    remover.run(getPassRunner(), &wasm);
-    remover.runOnModuleCode(getPassRunner(), &wasm);
+    PassRunner runner(getPassRunner());
+    runner.add(std::make_unique<FieldRemover>(*this));
+    runner.add(std::make_unique<IndexUpdater>(*this));
+    runner.run();
+
+    FieldRemover moduleRemover(*this);
+    moduleRemover.runOnModuleCode(getPassRunner(), &wasm);
 
     // Insert globals necessary to preserve instantiation-time trapping of
     // removed expressions.
-    for (Index i = 0; i < remover.removedTrappingInits.size(); ++i) {
-      auto* curr = remover.removedTrappingInits[i];
+    for (Index i = 0; i < moduleRemover.removedTrappingInits.size(); ++i) {
+      auto* curr = moduleRemover.removedTrappingInits[i];
       auto name = Names::getValidGlobalName(
         wasm, std::string("gto-removed-") + std::to_string(i));
       wasm.addGlobal(
         Builder::makeGlobal(name, curr->type, curr, Builder::Immutable));
     }
+
+    IndexUpdater moduleUpdater(*this);
+    moduleUpdater.runOnModuleCode(getPassRunner(), &wasm);
   }
 };
 
diff --git a/src/passes/HeapStoreOptimization.cpp b/src/passes/HeapStoreOptimization.cpp
index 6c6e729e744..118c44998d9 100644
--- a/src/passes/HeapStoreOptimization.cpp
+++ b/src/passes/HeapStoreOptimization.cpp
@@ -165,8 +165,8 @@ struct HeapStoreOptimization
   bool trySwap(ExpressionList& list, Index i, Index j) {
     if (j == list.size() - 1) {
       // There is no reason to swap with the last element of the list as it
-      // won't match the pattern because there wont be anything after. This also
-      // avoids swapping an instruction that does not leave anything in the
+      // won't match the pattern because there won't be anything after. This
+      // also avoids swapping an instruction that does not leave anything in the
       // stack by one that could leave something, and that which would be
       // incorrect.
       return false;
diff --git a/src/passes/Inlining.cpp b/src/passes/Inlining.cpp
index eeee2d8b8b8..18fe7069038 100644
--- a/src/passes/Inlining.cpp
+++ b/src/passes/Inlining.cpp
@@ -837,9 +837,9 @@ struct FunctionSplitter {
   //
   // Note that to avoid wasteful work, this function may return "Full" inlining
   // mode instead of a split inlining. That is, if it detects that a partial
-  // inlining will trigger a follow up full inline of the splitted function
-  // then it will instead return "InliningMode::Full" directly. In more detail,
-  // imagine we have
+  // inlining will trigger a follow up full inline of the split function then it
+  // will instead return "InliningMode::Full" directly. In more detail, imagine
+  // we have
   //
   //   foo(10);
   //
diff --git a/src/passes/Intrinsics.cpp b/src/passes/Intrinsics.cpp
index faba23816bb..97a7936e987 100644
--- a/src/passes/Intrinsics.cpp
+++ b/src/passes/Intrinsics.cpp
@@ -39,9 +39,11 @@ struct IntrinsicLowering : public WalkerPass<PostWalker<IntrinsicLowering>> {
       // forgets to optimize.
       Builder builder(*getModule());
       if (auto* refFunc = target->dynCast<RefFunc>()) {
-        replaceCurrent(builder.makeCall(refFunc->func, operands, curr->type));
+        replaceCurrent(builder.makeCall(
+          refFunc->func, operands, curr->type, curr->isReturn));
       } else {
-        replaceCurrent(builder.makeCallRef(target, operands, curr->type));
+        replaceCurrent(
+          builder.makeCallRef(target, operands, curr->type, curr->isReturn));
       }
     }
   }
diff --git a/src/passes/MakeSharedObjects.cpp b/src/passes/MakeSharedObjects.cpp
index 71af94ac74b..8a52fb79948 100644
--- a/src/passes/MakeSharedObjects.cpp
+++ b/src/passes/MakeSharedObjects.cpp
@@ -31,6 +31,17 @@
 // accordingly. Use i31 references to represent the table indices to avoid
 // further complications from mapping function references to non-reference
 // values.
+//
+// Although the shared objects prototype supports shared externrefs in general,
+// it is not the case that arbitrary unshared externrefs can be made shared. To
+// work around this, also lower unshared externrefs to i31ref table indices.
+// Unlike function references, which we assume form a closed set whose table
+// indices are meaningful across threads, there can be an arbitrary number of
+// externrefs at runtime and only those that are imported as globals can be
+// assumed to be meaningful across different threads. As a result, the externref
+// table supports growing over time and externrefs rather than their table
+// indices are still passed at the module boundary, unlike for function
+// references.
 
 #include "ir/drop.h"
 #include "ir/module-utils.h"
@@ -51,20 +62,229 @@
 
 namespace wasm {
 
+// Track several components used to store references in a table:
+//  - The table itself
+//  - Runtime functions for converting between references and table indices
+//  - Utilities for inserting calls to these runtime functions as necessary.
+// The table and runtime functions are only added to the module if they are
+// used.
+struct LazyTable {
+  Module* wasm = nullptr;
+  // The desired table name.
+  Name base;
+  // The non-conflicting version of `base`, if ever accessed.
+  Name name;
+  // The table type.
+  Type type;
+  // The names of conversion functions, if ever used.
+  Name refToIndexName;
+  Name indexToRefName;
+
+  LazyTable(Name base, Type type) : base(base), type(type) {}
+
+  Name getName() {
+    assert(wasm);
+    if (!name) {
+      name = Names::getValidTableName(*wasm, base);
+    }
+    return name;
+  }
+
+  Name getRefToIndexName() {
+    assert(wasm);
+    if (!refToIndexName) {
+      std::string funcName = type.getHeapType().toString() + "_to_index";
+      refToIndexName = Names::getValidFunctionName(*wasm, funcName);
+      getName();
+    }
+    return refToIndexName;
+  }
+
+  Name getIndexToRefName() {
+    assert(wasm);
+    if (!indexToRefName) {
+      std::string funcName = "index_to_" + type.getHeapType().toString();
+      indexToRefName = Names::getValidFunctionName(*wasm, funcName);
+      getName();
+    }
+    return indexToRefName;
+  }
+
+  void addRefToIndexFunction() {
+    // (func $<t>_to_index (param $ref <t>) (result (ref null (shared i31)))
+    //   (local $idx i32)
+    //   (if (result (ref null (shared i31)))
+    //     (ref.is_null (local.get $ref))
+    //     (then
+    //       (ref.null (shared none))
+    //     )
+    //     (else
+    //       (if (result (ref (shared i31)))
+    //         (i32.ge_s
+    //           (local.tee $idx
+    //             (table.grow $<table> (local.get $ref) (i32.const 1))
+    //           )
+    //           (i32.const 0)
+    //         )
+    //         (then
+    //           (ref.i31_shared (local.get $idx))
+    //         )
+    //         (else
+    //           (unreachable)
+    //         )
+    //       )
+    //     )
+    //   )
+    // )
+    Builder builder(*wasm);
+
+    Type sharedI31Nullable = Type(HeapTypes::i31.getBasic(Shared), Nullable);
+    Type sharedI31NonNull = Type(HeapTypes::i31.getBasic(Shared), NonNullable);
+    auto* isNull = builder.makeRefIsNull(builder.makeLocalGet(0, type));
+    auto* retNull = builder.makeRefNull(HeapTypes::none.getBasic(Shared));
+    auto* grow = builder.makeTableGrow(getName(),
+                                       builder.makeLocalGet(0, type),
+                                       builder.makeConst(Literal(int32_t(1))));
+    auto* tee = builder.makeLocalTee(1, grow, Type::i32);
+    auto* geZero =
+      builder.makeBinary(GeSInt32, tee, builder.makeConst(Literal(int32_t(0))));
+    auto* retIndex =
+      builder.makeRefI31(builder.makeLocalGet(1, Type::i32), Shared);
+    auto* checkGrow = builder.makeIf(
+      geZero, retIndex, builder.makeUnreachable(), sharedI31NonNull);
+
+    auto* body = builder.makeIf(isNull, retNull, checkGrow, sharedI31Nullable);
+    auto func = Builder::makeFunction(
+      refToIndexName, Signature(type, sharedI31Nullable), {Type::i32}, body);
+    func->hasExplicitName = true;
+    wasm->addFunction(std::move(func));
+  }
+
+  void addIndexToRefFunction() {
+    // (func $index_to_<t> (param $idx (ref null (shared i31))) (result <t>)
+    //   (if (result <type>)
+    //     (ref.is_null (local.get $idx))
+    //     (then
+    //       (ref.null <bottom>)
+    //     )
+    //     (else
+    //       (table.get $<table> (i31.get_u (local.get $idx)))
+    //     )
+    //   )
+    // )
+    Builder builder(*wasm);
+
+    Type sharedI31Nullable = Type(HeapTypes::i31.getBasic(Shared), Nullable);
+    auto* isNull =
+      builder.makeRefIsNull(builder.makeLocalGet(0, sharedI31Nullable));
+    auto* retNull = builder.makeRefNull(type.getHeapType().getBottom());
+    auto* getRef = builder.makeTableGet(
+      getName(),
+      builder.makeI31Get(builder.makeLocalGet(0, sharedI31Nullable), false),
+      type);
+
+    auto* body = builder.makeIf(isNull, retNull, getRef, type);
+    auto func = Builder::makeFunction(
+      indexToRefName, Signature(sharedI31Nullable, type), {}, body);
+    func->hasExplicitName = true;
+    wasm->addFunction(std::move(func));
+  }
+
+  // Returns true if the table was added. (If it is never used, it will not be
+  // added.)
+  bool maybeAdd(Address initial, Address max) {
+    assert(wasm);
+    if (!name) {
+      return false;
+    }
+    Table* table = wasm->addTable(Builder::makeTable(name));
+    table->type = type;
+    table->initial = initial;
+    table->max = max;
+    if (refToIndexName) {
+      addRefToIndexFunction();
+    }
+    if (indexToRefName) {
+      addIndexToRefFunction();
+    }
+    return true;
+  }
+
+  bool isTableType(Type t) const {
+    return t.isRef() && Type::isSubType(t, type);
+  }
+
+  bool hasTableType(Type t) const {
+    if (t.isTuple()) {
+      for (Type elem : t) {
+        if (hasTableType(elem)) {
+          return true;
+        }
+      }
+      return false;
+    }
+    return isTableType(t);
+  }
+
+  bool funcHasTableType(Function* func) const {
+    Signature sig = func->type.getHeapType().getSignature();
+    return hasTableType(sig.params) || hasTableType(sig.results);
+  }
+
+  Expression* convertToRef(Expression* arg, Type origType) {
+    if (!isTableType(origType)) {
+      return arg;
+    }
+    Builder builder(*wasm);
+    Expression* res = builder.makeCall(getIndexToRefName(), {arg}, type);
+    if (origType != type) {
+      res = builder.makeRefCast(res, origType);
+    }
+    return res;
+  }
+
+  Expression* convertToIndex(Expression* arg, Type origType, Type targetType) {
+    if (!isTableType(origType)) {
+      return arg;
+    }
+    Builder builder(*wasm);
+    Type sharedI31Nullable = Type(HeapTypes::i31.getBasic(Shared), Nullable);
+    Expression* res =
+      builder.makeCall(getRefToIndexName(), {arg}, sharedI31Nullable);
+    if (targetType.isNonNullable()) {
+      res = builder.makeRefAs(RefAsNonNull, res);
+    }
+    return res;
+  }
+};
+
 struct MakeSharedObjects
   : WalkerPass<PostWalker<MakeSharedObjects,
                           UnifiedExpressionVisitor<MakeSharedObjects>>> {
-  Name tableName;
+  Type funcref = Type(HeapTypes::func, Nullable);
+  Type externref = Type(HeapTypes::ext, Nullable);
+
+  LazyTable funcTable{"funcs", funcref};
+  LazyTable externTable{"externs", externref};
   std::vector<Name> funcs;
   std::unordered_map<Name, Index> funcIndices;
+  Name anyToExternName;
+  Name externToAnyName;
 
-  Type funcref = Type(HeapTypes::func, Nullable);
+  Name getAnyToExternName() {
+    if (!anyToExternName) {
+      anyToExternName =
+        Names::getValidFunctionName(*getModule(), "any_to_extern");
+    }
+    return anyToExternName;
+  }
 
-  Name getTable() {
-    if (!tableName) {
-      tableName = Names::getValidTableName(*getModule(), "funcs");
+  Name getExternToAnyName() {
+    if (!externToAnyName) {
+      externToAnyName =
+        Names::getValidFunctionName(*getModule(), "extern_to_any");
     }
-    return tableName;
+    return externToAnyName;
   }
 
   Index getIndex(Name func) {
@@ -82,6 +302,12 @@ struct MakeSharedObjects
     if (type.isMaybeShared(HeapType::nofunc)) {
       return HeapTypes::none.getBasic(Shared);
     }
+    if (type == HeapType::ext || type == HeapType::string) {
+      return HeapTypes::i31.getBasic(Shared);
+    }
+    if (type == HeapType::noext) {
+      return HeapTypes::none.getBasic(Shared);
+    }
     if (type.isBasic()) {
       return type.getBasic(Shared);
     }
@@ -109,6 +335,157 @@ struct MakeSharedObjects
 
   void updateType(Type& type) { type = updatedType(type); }
 
+  Type getBoundaryType(Type origType, Type rewrittenType) {
+    Signature origSig = origType.getHeapType().getSignature();
+    Signature rewrittenSig = rewrittenType.getHeapType().getSignature();
+
+    std::vector<Type> params;
+    Index i = 0;
+    for (Type param : origSig.params) {
+      if (externTable.isTableType(param)) {
+        params.push_back(param);
+      } else {
+        params.push_back(rewrittenSig.params[i]);
+      }
+      ++i;
+    }
+
+    std::vector<Type> results;
+    Index j = 0;
+    for (Type result : origSig.results) {
+      if (externTable.isTableType(result)) {
+        results.push_back(result);
+      } else {
+        results.push_back(rewrittenSig.results[j]);
+      }
+      ++j;
+    }
+
+    return Type(Signature(Type(params), Type(results)),
+                NonNullable,
+                origType.getExactness());
+  }
+
+  void wrapImport(Function* func, Type origType) {
+    // Create a new imported function with the boundary type. The original
+    // function (which has lowered param and result types) is no longer an
+    // import and is given a body that calls the new import and converts the
+    // externrefs to and from indices.
+    Builder builder(*getModule());
+    Name origName = func->name;
+    Name importName = Names::getValidFunctionName(
+      *getModule(), origName.toString() + "$import");
+
+    Type boundaryType = getBoundaryType(origType, func->type);
+
+    auto importFunc = std::make_unique<Function>();
+    importFunc->name = importName;
+    importFunc->module = func->module;
+    importFunc->base = func->base;
+    importFunc->type = boundaryType;
+    importFunc->hasExplicitName = true;
+
+    func->module = Name();
+    func->base = Name();
+    func->type = Type(func->type.getHeapType(), NonNullable, Exact);
+
+    // Convert indices passed as params to externrefs.
+    Signature boundarySig = boundaryType.getHeapType().getSignature();
+    std::vector<Expression*> callArgs;
+    Index i = 0;
+    for (Type param : boundarySig.params) {
+      Type localType = func->getParams()[i];
+      Expression* get = builder.makeLocalGet(i, localType);
+      callArgs.push_back(externTable.convertToRef(get, param));
+      ++i;
+    }
+
+    Type extResults = boundarySig.results;
+    auto* call = builder.makeCall(importName, callArgs, extResults);
+
+    // Convert externrefs received as results to indices.
+    if (!externTable.hasTableType(extResults)) {
+      func->body = call;
+    } else if (extResults.isSingle()) {
+      Type targetType = func->getResults();
+      func->body = externTable.convertToIndex(call, extResults, targetType);
+    } else {
+      Index scratch = Builder::addVar(func, extResults);
+      auto* set = builder.makeLocalSet(scratch, call);
+      std::vector<Expression*> tupleElems;
+      Index j = 0;
+      for (Type t : extResults) {
+        auto* extract = builder.makeTupleExtract(
+          builder.makeLocalGet(scratch, extResults), j);
+        tupleElems.push_back(
+          externTable.convertToIndex(extract, t, func->getResults()[j]));
+        ++j;
+      }
+      auto* tupleMake = builder.makeTupleMake(tupleElems);
+      func->body = builder.makeBlock({set, tupleMake});
+    }
+
+    getModule()->addFunction(std::move(importFunc));
+  }
+
+  Name wrapExport(Export* ex, Type origType) {
+    // Wrap the exported function with a new function that calls the original
+    // exported function, converting externref params into indices and index
+    // results into externrefs.
+    Builder builder(*getModule());
+    auto* internalFunc = getModule()->getFunction(*ex->getInternalName());
+    Name origName = internalFunc->name;
+    Name exportWrapperName = Names::getValidFunctionName(
+      *getModule(), origName.toString() + "$export");
+
+    Type boundaryType = getBoundaryType(origType, internalFunc->type);
+
+    auto exportWrapper = std::make_unique<Function>();
+    exportWrapper->name = exportWrapperName;
+    exportWrapper->type = Type(boundaryType.getHeapType(), NonNullable, Exact);
+    exportWrapper->hasExplicitName = true;
+
+    // Forward params, converting externrefs to indices.
+    Signature boundarySig = boundaryType.getHeapType().getSignature();
+    std::vector<Expression*> callArgs;
+    Index i = 0;
+    for (Type param : boundarySig.params) {
+      Type localType = exportWrapper->getParams()[i];
+      Expression* get = builder.makeLocalGet(i, localType);
+      Type targetType = internalFunc->getParams()[i];
+      callArgs.push_back(externTable.convertToIndex(get, param, targetType));
+      ++i;
+    }
+
+    Type internalResults = internalFunc->getResults();
+    auto* call = builder.makeCall(origName, callArgs, internalResults);
+
+    // Forward results, converting indices to externrefs.
+    Type extResults = boundarySig.results;
+    if (!externTable.hasTableType(extResults)) {
+      exportWrapper->body = call;
+    } else if (extResults.isSingle()) {
+      exportWrapper->body = externTable.convertToRef(call, extResults);
+    } else {
+      Index scratch = Builder::addVar(exportWrapper.get(), internalResults);
+      auto* set = builder.makeLocalSet(scratch, call);
+      std::vector<Expression*> tupleElems;
+      Index j = 0;
+      for (Type t : extResults) {
+        auto* extract = builder.makeTupleExtract(
+          builder.makeLocalGet(scratch, internalResults), j);
+        tupleElems.push_back(externTable.convertToRef(extract, t));
+        ++j;
+      }
+      auto* tupleMake = builder.makeTupleMake(tupleElems);
+      exportWrapper->body = builder.makeBlock({set, tupleMake});
+    }
+
+    getModule()->addFunction(std::move(exportWrapper));
+    ex->setInternalName(exportWrapperName);
+    return exportWrapperName;
+  }
+
   void visitRefFunc(RefFunc* curr) {
     Builder builder(*getModule());
     replaceCurrent(builder.makeRefI31(
@@ -154,7 +531,7 @@ struct MakeSharedObjects
     auto type = it->second;
     callRefTypes.erase(it);
     replaceCurrent(
-      builder.makeCallIndirect(getTable(),
+      builder.makeCallIndirect(funcTable.getName(),
                                builder.makeI31Get(curr->target, false),
                                curr->operands,
                                type,
@@ -168,7 +545,7 @@ struct MakeSharedObjects
     Type oldTableType = updatedType(getModule()->getTable(oldTable)->type);
     auto* index = builder.makeTableGet(oldTable, curr->target, oldTableType);
     curr->target = builder.makeI31Get(index, false);
-    curr->table = getTable();
+    curr->table = funcTable.getName();
   }
 
   void visitRefTest(RefTest* curr) {
@@ -190,7 +567,7 @@ struct MakeSharedObjects
     if (curr->ref->type.isNonNullable()) {
       // (ref.test castType (table.get $t (i31.get_u ref)))
       curr->ref = builder.makeTableGet(
-        getTable(), builder.makeI31Get(curr->ref, false), funcref);
+        funcTable.getName(), builder.makeI31Get(curr->ref, false), funcref);
       return;
     }
     // (if (result i32)
@@ -207,7 +584,7 @@ struct MakeSharedObjects
     auto* ifNull =
       builder.makeConst(Literal(int32_t(curr->castType.isNullable())));
     curr->ref = builder.makeTableGet(
-      getTable(),
+      funcTable.getName(),
       builder.makeI31Get(builder.makeLocalGet(scratch, scratchType), false),
       funcref);
     replaceCurrent(builder.makeIf(cond, ifNull, curr, Type::i32));
@@ -260,7 +637,7 @@ struct MakeSharedObjects
     }
     auto* getScratch = builder.makeLocalGet(scratch, scratchType);
     auto* i31get = builder.makeI31Get(getScratch, false);
-    auto* tableGet = builder.makeTableGet(getTable(), i31get, funcref);
+    auto* tableGet = builder.makeTableGet(funcTable.getName(), i31get, funcref);
     auto* refTest = builder.makeRefTest(tableGet, curr->type);
     Expression* ifPass = builder.makeLocalGet(scratch, scratchType);
     if (curr->type.isNonNullable()) {
@@ -288,6 +665,31 @@ struct MakeSharedObjects
     WASM_UNREACHABLE("TODO: br_on");
   }
 
+  void visitRefAs(RefAs* curr) {
+    if (curr->type == Type::unreachable) {
+      return;
+    }
+    if (curr->op == AnyConvertExtern) {
+      Type extType = Type(HeapTypes::ext, curr->type.getNullability());
+      Expression* ext = externTable.convertToRef(curr->value, extType);
+      Builder builder(*getModule());
+      Type sharedAnyNullable = Type(HeapTypes::any.getBasic(Shared), Nullable);
+      Expression* call =
+        builder.makeCall(getExternToAnyName(), {ext}, sharedAnyNullable);
+      if (curr->type.isNonNullable()) {
+        call = builder.makeRefAs(RefAsNonNull, call);
+      }
+      replaceCurrent(call);
+    } else if (curr->op == ExternConvertAny) {
+      Builder builder(*getModule());
+      Expression* call =
+        builder.makeCall(getAnyToExternName(), {curr->value}, externref);
+      Type extType = Type(HeapTypes::ext, curr->type.getNullability());
+      Type targetType = updatedType(curr->type);
+      replaceCurrent(externTable.convertToIndex(call, extType, targetType));
+    }
+  }
+
   void visitExpression(Expression* curr) {
     updateType(curr->type);
 
@@ -319,13 +721,60 @@ struct MakeSharedObjects
   void visitGlobal(Global* curr) { updateType(curr->type); }
 
   void doWalkModule(Module* wasm) {
+    funcTable.wasm = wasm;
+    externTable.wasm = wasm;
     wasm->features.setSharedEverything();
     WalkerPass::doWalkModule(wasm);
   }
 
+  struct ImportToWrap {
+    Function* func;
+    Type origType;
+  };
+
+  struct ExportToWrap {
+    Export* ex;
+    Type origType;
+  };
+
   void visitModule(Module* wasm) {
+    std::vector<ImportToWrap> importsToWrap;
+    for (auto& func : wasm->functions) {
+      if (func->imported() && externTable.funcHasTableType(func.get())) {
+        importsToWrap.push_back({func.get(), func->type});
+      }
+    }
+
+    std::vector<ExportToWrap> exportsToWrap;
+    for (auto& ex : wasm->exports) {
+      if (ex->kind == ExternalKind::Function) {
+        if (auto* name = ex->getInternalName()) {
+          auto* func = wasm->getFunction(*name);
+          if (externTable.funcHasTableType(func)) {
+            exportsToWrap.push_back(ExportToWrap{ex.get(), func->type});
+          }
+        }
+      }
+    }
+
     rewriteTypes();
+
+    for (auto& info : importsToWrap) {
+      wrapImport(info.func, info.origType);
+    }
+    std::unordered_map<Function*, Name> wrappedExports;
+    for (auto& info : exportsToWrap) {
+      auto* internalFunc = wasm->getFunction(*info.ex->getInternalName());
+      auto [it, inserted] = wrappedExports.insert({internalFunc, Name()});
+      if (inserted) {
+        it->second = wrapExport(info.ex, info.origType);
+      } else {
+        info.ex->setInternalName(it->second);
+      }
+    }
+
     addFunctionTable();
+    addExternTable();
     ReFinalize().run(getPassRunner(), wasm);
   }
 
@@ -352,8 +801,9 @@ struct MakeSharedObjects
         if (auto super = info.types[i].getDeclaredSuperType()) {
           builder[i].subTypeOf(builder[info.indices.at(*super)]);
         }
+      } else {
+        builder[i].setShared(Shared);
       }
-      builder[i].setShared(info.types[i].isSignature() ? Unshared : Shared);
     }
 
     auto built = builder.build();
@@ -373,18 +823,18 @@ struct MakeSharedObjects
   }
 
   void addFunctionTable() {
-    if (!tableName) {
+    if (!funcTable.maybeAdd(funcs.size(), funcs.size())) {
+      return;
+    }
+    if (funcs.empty()) {
       return;
     }
     Builder builder(*getModule());
-    Table* table = getModule()->addTable(Builder::makeTable(tableName));
-    table->type = funcref;
-    table->initial = table->max = funcs.size();
     Name segName = Names::getValidElementSegmentName(*getModule(), "funcs");
     auto* offset = builder.makeConst(Literal(int32_t(0)));
     auto* segment = getModule()->addElementSegment(
-      Builder::makeElementSegment(segName, tableName, offset));
-    segment->type = funcref;
+      Builder::makeElementSegment(segName, funcTable.getName(), offset));
+    segment->type = funcTable.type;
 
     segment->data.reserve(funcs.size());
     for (auto func : funcs) {
@@ -393,6 +843,38 @@ struct MakeSharedObjects
     }
   }
 
+  void addAnyToExternFunction() {
+    Type sharedAnyNullable = Type(HeapTypes::any.getBasic(Shared), Nullable);
+    Type externrefNullable = Type(HeapTypes::ext, Nullable);
+    auto importFunc = Builder::makeFunction(
+      anyToExternName, Signature(sharedAnyNullable, externrefNullable), {});
+    importFunc->module = "env";
+    importFunc->base = "any_to_extern";
+    importFunc->hasExplicitName = true;
+    getModule()->addFunction(std::move(importFunc));
+  }
+
+  void addExternToAnyFunction() {
+    Type externrefNullable = Type(HeapTypes::ext, Nullable);
+    Type sharedAnyNullable = Type(HeapTypes::any.getBasic(Shared), Nullable);
+    auto importFunc = Builder::makeFunction(
+      externToAnyName, Signature(externrefNullable, sharedAnyNullable), {});
+    importFunc->module = "env";
+    importFunc->base = "extern_to_any";
+    importFunc->hasExplicitName = true;
+    getModule()->addFunction(std::move(importFunc));
+  }
+
+  void addExternTable() {
+    externTable.maybeAdd(0, Table::kUnlimitedSize);
+    if (anyToExternName) {
+      addAnyToExternFunction();
+    }
+    if (externToAnyName) {
+      addExternToAnyFunction();
+    }
+  }
+
   std::unique_ptr<Pass> create() override {
     return std::make_unique<MakeSharedObjects>();
   }
diff --git a/src/passes/MergeBlocks.cpp b/src/passes/MergeBlocks.cpp
index 7010d6d15f7..59f125cc61f 100644
--- a/src/passes/MergeBlocks.cpp
+++ b/src/passes/MergeBlocks.cpp
@@ -236,7 +236,7 @@ static bool hasDeadCode(Block* block) {
 }
 
 // Given a dropped block, see if we can simplify it by optimizing the drop into
-// the block, removing the return value while doin so. Returns whether we
+// the block, removing the return value while doing so. Returns whether we
 // succeeded.
 static bool optimizeDroppedBlock(Drop* drop,
                                  Block* block,
diff --git a/src/passes/MultiMemoryLowering.cpp b/src/passes/MultiMemoryLowering.cpp
index 7a106410a84..ffc489df7bf 100644
--- a/src/passes/MultiMemoryLowering.cpp
+++ b/src/passes/MultiMemoryLowering.cpp
@@ -604,7 +604,7 @@ struct MultiMemoryLowering : public Pass {
         builder.makeReturn(builder.makeConst(-1))));
 
     // If we are not growing the last memory, then we need to copy data,
-    // shifting it over to accomodate the increase from page_delta
+    // shifting it over to accommodate the increase from page_delta
     if (!isLastMemory(memIdx)) {
       // This offset is the starting pt for copying
       auto offsetGlobalName = getOffsetGlobal(memIdx + 1);
diff --git a/src/passes/OptimizeCasts.cpp b/src/passes/OptimizeCasts.cpp
index a6ea8fa2ac2..25852027a0c 100644
--- a/src/passes/OptimizeCasts.cpp
+++ b/src/passes/OptimizeCasts.cpp
@@ -315,7 +315,7 @@ struct EarlyCastFinder
     // (ref.cast $B (ref.cast $B (local.get $x)))
     //
     // We initially choose to move the inner ref.cast $B. When we consider the
-    // outer ref.cast $B, we can see that it has the same type as tge existing
+    // outer ref.cast $B, we can see that it has the same type as the existing
     // ref.cast $B, so we ignore it.
     //
     // Case 4:
diff --git a/src/passes/OptimizeInstructions.cpp b/src/passes/OptimizeInstructions.cpp
index aa093530543..b862dd9e45c 100644
--- a/src/passes/OptimizeInstructions.cpp
+++ b/src/passes/OptimizeInstructions.cpp
@@ -49,6 +49,7 @@
 
 #include "call-utils.h"
 #include "support/utilities.h"
+#include "wasm-type.h"
 
 // TODO: Use the new sign-extension opcodes where appropriate. This needs to be
 // conditionalized on the availability of atomics.
@@ -1461,6 +1462,65 @@ struct OptimizeInstructions
     }
   }
 
+  void visitResume(Resume* curr) {
+    skipNonNullCast(curr->cont, curr);
+    if (trapOnNull(curr, curr->cont)) {
+      return;
+    }
+    if (curr->type == Type::unreachable) {
+      return;
+    }
+
+    // If this resume operates on a freshly-created continuation of an exact
+    // function that is known never to suspend, we can turn the resumption into
+    // a direct call, avoiding the continuation allocation and handler overhead.
+
+    // Continuations are single-shot, so resuming a continuation that has
+    // already been consumed will trap. If traps are assumed never to happen, we
+    // can assume this continuation will not be consumed on another path and
+    // look through tees and conditional branches. Otherwise, avoid looking
+    // through them to ensure the continuation cannot be consumed elsewhere.
+    auto behavior = getPassOptions().trapsNeverHappen
+                      ? Properties::FallthroughBehavior::AllowTeeBrIf
+                      : Properties::FallthroughBehavior::NoTeeBrIf;
+
+    auto* contExpr = Properties::getFallthrough(
+      curr->cont, getPassOptions(), *getModule(), behavior);
+    auto* contNew = contExpr->dynCast<ContNew>();
+    if (!contNew) {
+      return;
+    }
+    if (contNew->func->type == Type::unreachable) {
+      return;
+    }
+
+    auto* funcExpr =
+      Properties::getFallthrough(contNew->func, getPassOptions(), *getModule());
+    auto* refFunc = funcExpr->dynCast<RefFunc>();
+    if (!refFunc) {
+      return;
+    }
+
+    auto* target = getModule()->getFunctionOrNull(refFunc->func);
+    if (!target || target->imported()) {
+      return;
+    }
+
+    if (!target->effects || target->effects->suspends) {
+      return;
+    }
+
+    auto* block =
+      ChildLocalizer(curr, getFunction(), *getModule(), getPassOptions())
+        .getChildrenReplacement();
+    Builder builder(*getModule());
+    Type results = target->getResults();
+    block->list.push_back(
+      builder.makeCall(target->name, curr->operands, results));
+    block->type = results;
+    replaceCurrent(block);
+  }
+
   // Note on removing casts (which the following utilities, skipNonNullCast and
   // skipCast do): removing a cast is potentially dangerous, as it removes
   // information from the IR. For example:
@@ -1551,6 +1611,17 @@ struct OptimizeInstructions
   // ref.as_non_null then the struct.set will still trap, of course, but that
   // will only happen *after* the call, which is wrong.
   void skipNonNullCast(Expression*& input, Expression* parent) {
+    // If we must never reorder code, then we cannot remove a non-null cast.
+    // Such removals are valid because we move the trap later (see the
+    // struct.set in the example above: we can remove the ref.as_non_null
+    // because the set will trap anyhow, so we are pushing the trap onward; in
+    // the example above we have a call we can't move past, and in neverReorder
+    // mode we need to care about things like branch hints, which do not have
+    // effects, hence the need for the special neverReorder flag).
+    if (neverReorder) {
+      return;
+    }
+
     // Check the other children for the ordering problem only if we find a
     // possible optimization, to avoid wasted work.
     bool checkedSiblings = false;
@@ -1717,7 +1788,7 @@ struct OptimizeInstructions
 
       if (auto* select = ref->dynCast<Select>()) {
         // We must check for unreachability explicitly here because a full
-        // refinalize only happens at the end. That is, the select may stil be
+        // refinalize only happens at the end. That is, the select may still be
         // reachable after we turned one child into an unreachable, and we are
         // calling getResultOfFirst which will error on unreachability.
         if (flowsOutNull(select->ifTrue) &&
@@ -2550,13 +2621,41 @@ struct OptimizeInstructions
       // traps are allowed, then we cannot remove the potentially-trapping
       // child, though.
       bool notWeaker = Type::isSubType(curr->type, child->type);
-      bool safe = !child->desc || getPassOptions().trapsNeverHappen;
-      if (notWeaker && safe) {
+      auto& options = getPassOptions();
+      auto canTrap = !options.trapsNeverHappen;
+      bool safe = !child->desc || !canTrap;
+      bool canOptimize = notWeaker && safe;
+      if (canOptimize && curr->desc && canTrap) {
+        // There is another child here, which might trap, and we need to
+        // consider that in this situation:
+        //
+        //  (outer.cast
+        //    (inner.cast (inner.ref))
+        //    (descriptor with effects)
+        //  )
+        //
+        //  =>
+        //
+        //  (outer.cast
+        //    (inner.ref)                ;; inner cast was removed
+        //    (descriptor with effects)
+        //  )
+        //
+        // It is safe to remove the inner cast, as if it trapped, the outer one
+        // would still trap. But if there is a descriptor, then we are moving
+        // the trap across the descriptor, and shouldn't cross effects there.
+        EffectAnalyzer descEffects(options, *getModule(), curr->desc);
+        ShallowEffectAnalyzer movingEffects(options, *getModule(), curr->ref);
+        if (movingEffects.orderedBefore(descEffects)) {
+          canOptimize = false;
+        }
+      }
+      if (canOptimize) {
         if (child->desc) {
           // Reorder the child's reference past its dropped descriptor if
           // necessary.
           auto* block =
-            ChildLocalizer(child, getFunction(), *getModule(), getPassOptions())
+            ChildLocalizer(child, getFunction(), *getModule(), options)
               .getChildrenReplacement();
           block->list.push_back(child->ref);
           block->type = child->ref->type;
@@ -2742,6 +2841,51 @@ struct OptimizeInstructions
     trapOnNull(curr, curr->ref);
   }
 
+  void visitPublish(Publish* curr) {
+    if (curr->type == Type::unreachable) {
+      return;
+    }
+
+    // Publish of a reference that cannot be a shared array or struct can be
+    // removed.
+    auto canBeSharedArrayOrStruct = [](Type type) {
+      if (!type.isRef()) {
+        return false;
+      }
+      auto ht = type.getHeapType();
+      if (ht.isBottom() || ht.isMaybeShared(HeapType::i31)) {
+        return false;
+      }
+      return HeapType::isSubType(ht, HeapTypes::any.getBasic(Shared));
+    };
+
+    if (!canBeSharedArrayOrStruct(getFallthroughType(curr->ref))) {
+      replaceCurrent(curr->ref);
+      return;
+    }
+
+    auto isAllocation = [](Expression* expr) {
+      return expr->is<StructNew>() || expr->is<ArrayNew>() ||
+             expr->is<ArrayNewData>() || expr->is<ArrayNewElem>() ||
+             expr->is<ArrayNewFixed>();
+    };
+
+    // Publish of publish or of a struct/array allocation can be removed.
+    Expression* fallthrough = curr->ref;
+    while (true) {
+      if (fallthrough->is<Publish>() || isAllocation(fallthrough)) {
+        replaceCurrent(curr->ref);
+        return;
+      }
+      auto* next = Properties::getImmediateFallthrough(
+        fallthrough, getPassOptions(), *getModule());
+      if (next == fallthrough) {
+        break;
+      }
+      fallthrough = next;
+    }
+  }
+
   void visitTupleExtract(TupleExtract* curr) {
     if (curr->type == Type::unreachable) {
       return;
@@ -2843,6 +2987,16 @@ struct OptimizeInstructions
         left = br->value;
         continue;
       }
+      if (auto* cast = left->dynCast<RefCast>(); cast && cast->desc) {
+        interferingEffects.walk(cast->desc);
+        left = cast->ref;
+        continue;
+      }
+      if (auto* br = left->dynCast<BrOn>(); br && br->desc) {
+        interferingEffects.walk(br->desc);
+        left = br->ref;
+        continue;
+      }
       // We have found the real fallthrough expression.
       break;
     }
@@ -4704,7 +4858,7 @@ struct OptimizeInstructions
       }
     }
     {
-      // TODO: Add cancelation for some large constants when shrinkLevel > 0
+      // TODO: Add cancellation for some large constants when shrinkLevel > 0
       // in FinalOptimizer.
 
       // (x >> C)  << C   =>   x & -(1 << C)
@@ -4729,7 +4883,7 @@ struct OptimizeInstructions
       }
     }
     {
-      // TODO: Add cancelation for some large constants when shrinkLevel > 0
+      // TODO: Add cancellation for some large constants when shrinkLevel > 0
       // in FinalOptimizer.
 
       // (x << C) >>> C   =>   x & (-1 >>> C)
diff --git a/src/passes/Precompute.cpp b/src/passes/Precompute.cpp
index 8f550bd27eb..a1357e6475c 100644
--- a/src/passes/Precompute.cpp
+++ b/src/passes/Precompute.cpp
@@ -1103,7 +1103,7 @@ struct Precompute
   // string.
   bool isValidUTF16Literal(const Literal& value) {
     bool expectLowSurrogate = false;
-    for (auto& v : value.getGCData()->values) {
+    for (auto& v : value.getGCData()->getLiterals()) {
       auto c = v.getInteger();
       if (c >= 0xDC00 && c <= 0xDFFF) {
         if (expectLowSurrogate) {
diff --git a/src/passes/Print.cpp b/src/passes/Print.cpp
index 50600001e9a..bcc6b7884ff 100644
--- a/src/passes/Print.cpp
+++ b/src/passes/Print.cpp
@@ -1360,7 +1360,7 @@ struct PrintExpressionContents
         o << "f16x8.demote_f64x2_zero";
         break;
       case InvalidUnary:
-        WASM_UNREACHABLE("unvalid unary operator");
+        WASM_UNREACHABLE("invalid unary operator");
     }
     restoreNormalColor(o);
   }
@@ -2033,7 +2033,7 @@ struct PrintExpressionContents
         break;
 
       case InvalidBinary:
-        WASM_UNREACHABLE("unvalid binary operator");
+        WASM_UNREACHABLE("invalid binary operator");
     }
     restoreNormalColor(o);
   }
@@ -2408,6 +2408,7 @@ struct PrintExpressionContents
   void visitWaitqueueNotify(WaitqueueNotify* curr) {
     printMedium(o, "waitqueue.notify");
   }
+  void visitPublish(Publish* curr) { printMedium(o, "publish"); }
   void visitArrayNew(ArrayNew* curr) {
     printMedium(o, "array.new");
     if (curr->isWithDefault()) {
@@ -3884,13 +3885,13 @@ static std::ostream& printStackIR(StackIR* ir, PrintSExpression& printer) {
     }
     switch (inst->op) {
       case StackInst::Basic: {
-        doIndent();
         // Pop is a pseudo instruction and should not be printed in the stack IR
         // format to make it valid wat form.
         if (inst->origin->is<Pop>()) {
-          break;
+          continue;
         }
 
+        doIndent();
         PrintExpressionContents(printer).visit(inst->origin);
         break;
       }
diff --git a/src/passes/RemoveEmptyFunctionExports.cpp b/src/passes/RemoveEmptyFunctionExports.cpp
new file mode 100644
index 00000000000..2e56a8007ca
--- /dev/null
+++ b/src/passes/RemoveEmptyFunctionExports.cpp
@@ -0,0 +1,60 @@
+/*
+ * Copyright 2026 WebAssembly Community Group participants
+ *
+ * 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.
+ */
+
+//
+// Remove exports of empty defined functions, for runtimes that treat missing
+// exports as optional. The functions themselves are left intact; run
+// --remove-unused-module-elements afterwards to remove any that become unused.
+//
+
+#include "pass.h"
+#include "wasm.h"
+
+namespace wasm {
+
+namespace {
+
+struct RemoveEmptyFunctionExports : public Pass {
+  // Only exports are removed, so function contents need no fixups.
+  bool requiresNonNullableLocalFixups() override { return false; }
+
+  void run(Module* module) override {
+    module->removeExports([&](Export* curr) {
+      if (curr->kind != ExternalKind::Function) {
+        return false;
+      }
+      const auto* func = module->getFunction(*curr->getInternalName());
+      if (func->imported()) {
+        return false;
+      }
+      if (func->body->is<Nop>()) {
+        return true;
+      }
+      if (auto* block = func->body->dynCast<Block>()) {
+        return block->list.empty();
+      }
+      return false;
+    });
+  }
+};
+
+} // anonymous namespace
+
+Pass* createRemoveEmptyFunctionExportsPass() {
+  return new RemoveEmptyFunctionExports();
+}
+
+} // namespace wasm
diff --git a/src/passes/TailCall.cpp b/src/passes/TailCall.cpp
new file mode 100644
index 00000000000..6a1b58e3505
--- /dev/null
+++ b/src/passes/TailCall.cpp
@@ -0,0 +1,326 @@
+/*
+ * Copyright 2026 WebAssembly Community Group participants
+ *
+ * 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.
+ */
+
+//
+// Convert calls in tail position to return calls (tail calls).
+//
+
+#include <unordered_set>
+
+#include "ir/effects.h"
+#include "ir/properties.h"
+#include "ir/utils.h"
+#include "pass.h"
+#include "wasm-traversal.h"
+#include "wasm.h"
+
+namespace wasm {
+
+namespace {
+
+// We are doing a pre-order traversal (i.e. parents before children) rather
+// than the normal post-order traversal because whether an expression is in
+// tail position is propagated down from parents to children. Define our own
+// pre-order traversal task stack, and take the opportunity to pass `isTail`
+// as an extra parameter to each task rather than storing it in a side table.
+template<typename SubType>
+struct PreWalker : public Walker<SubType, Visitor<SubType>> {
+  using TaskFunc = void (*)(SubType*, Expression**, bool);
+
+  struct Task {
+    TaskFunc func;
+    Expression** currp;
+    bool isTail;
+    Task() = default;
+    Task(TaskFunc func, Expression** currp, bool isTail)
+      : func(func), currp(currp), isTail(isTail) {}
+  };
+
+  SmallVector<Task, 10> stack;
+
+  void push(Expression** currp, bool isTail) {
+    assert(*currp);
+    stack.emplace_back(doVisit, currp, isTail);
+  }
+
+  void maybePush(Expression** currp, bool isTail) {
+    if (*currp) {
+      stack.emplace_back(doVisit, currp, isTail);
+    }
+  }
+
+  Task popTask() {
+    auto ret = stack.back();
+    stack.pop_back();
+    return ret;
+  }
+
+  static void doVisit(SubType* self, Expression** currp, bool isTail) {
+    self->visit(*currp, isTail);
+  }
+
+  void walk(Expression*& root) {
+    assert(stack.empty());
+    push(&root, true);
+    while (!stack.empty()) {
+      auto task = popTask();
+      task.func(static_cast<SubType*>(this), task.currp, task.isTail);
+    }
+  }
+
+  void doWalkFunction(Function* func) { walk(func->body); }
+
+  void visitExpression(Expression* curr, bool isTail) {
+    assert(!Properties::isControlFlowStructure(curr) &&
+           "unexpected control flow structure");
+
+#define DELEGATE_ID curr->_id
+#define DELEGATE_START(id) [[maybe_unused]] auto* cast = curr->cast<id>();
+#define DELEGATE_END(id)
+#define DELEGATE_GET_FIELD(id, field) cast->field
+#define DELEGATE_FIELD_CHILD(id, field) push(&cast->field, false);
+#define DELEGATE_FIELD_OPTIONAL_CHILD(id, field) maybePush(&cast->field, false);
+#define DELEGATE_FIELD_INT(id, field)
+#define DELEGATE_FIELD_LITERAL(id, field)
+#define DELEGATE_FIELD_NAME(id, field)
+#define DELEGATE_FIELD_SCOPE_NAME_DEF(id, field)
+#define DELEGATE_FIELD_SCOPE_NAME_USE(id, field)
+#define DELEGATE_FIELD_TYPE(id, field)
+#define DELEGATE_FIELD_HEAPTYPE(id, field)
+#define DELEGATE_FIELD_ADDRESS(id, field)
+
+#include "wasm-delegations-fields.def"
+  }
+
+#define DELEGATE(CLASS_TO_VISIT)                                               \
+  void visit##CLASS_TO_VISIT(CLASS_TO_VISIT* curr, bool isTail) {              \
+    static_cast<SubType*>(this)->visitExpression(curr, isTail);                \
+  }
+
+#include "wasm-delegations.def"
+
+  void visit(Expression* curr, bool isTail) {
+    assert(curr);
+    switch (curr->_id) {
+#define DELEGATE(CLASS_TO_VISIT)                                               \
+  case Expression::Id::CLASS_TO_VISIT##Id:                                     \
+    return static_cast<SubType*>(this)->visit##CLASS_TO_VISIT(                 \
+      static_cast<CLASS_TO_VISIT*>(curr), isTail);
+
+#include "wasm-delegations.def"
+
+      default:
+        WASM_UNREACHABLE("unexpected expression type");
+    }
+  }
+};
+
+struct TailCall : public WalkerPass<PreWalker<TailCall>> {
+  bool isFunctionParallel() override { return true; }
+
+  std::unique_ptr<Pass> create() override {
+    return std::make_unique<TailCall>();
+  }
+
+  // Names of blocks whose exit flows directly out of the function.
+  std::unordered_set<Name> tailBlocks;
+  // Nesting depth of active exception handlers that catch or redirect
+  // exceptions within the current function.
+  size_t ehDepth = 0;
+  // Whether any call in the current function was converted to a return call.
+  bool changed = false;
+
+  void pushEnterTry() { stack.emplace_back(doEnterTryBody, nullptr, false); }
+
+  void pushLeaveTry() { stack.emplace_back(doLeaveTryBody, nullptr, false); }
+
+  static void doEnterTryBody(TailCall* self, Expression**, bool) {
+    ++self->ehDepth;
+  }
+
+  static void doLeaveTryBody(TailCall* self, Expression**, bool) {
+    assert(self->ehDepth > 0);
+    --self->ehDepth;
+  }
+
+  bool hasUnremovableSideEffects(Expression* expr) {
+    return EffectAnalyzer(getPassOptions(), *getModule(), expr)
+      .hasUnremovableSideEffects();
+  }
+
+  bool allTargetsInTailBlocks(Switch* curr) {
+    if (!tailBlocks.contains(curr->default_)) {
+      return false;
+    }
+    for (auto target : curr->targets) {
+      if (!tailBlocks.contains(target)) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  bool isTailTransfer(Break* curr, bool isTail) {
+    if (!tailBlocks.contains(curr->name)) {
+      return false;
+    }
+    // Converting a call in a conditional branch or br_table to a return_call
+    // skips evaluating the condition, so the condition must not have side
+    // effects.
+    return !curr->condition ||
+           (isTail && !hasUnremovableSideEffects(curr->condition));
+  }
+
+  bool isTailTransfer(Switch* curr) {
+    return allTargetsInTailBlocks(curr) &&
+           !hasUnremovableSideEffects(curr->condition);
+  }
+
+  bool isTailTransfer(Expression* curr, bool isTail) {
+    if (curr->is<Return>()) {
+      return true;
+    }
+    if (auto* br = curr->dynCast<Break>()) {
+      return isTailTransfer(br, isTail);
+    }
+    if (auto* sw = curr->dynCast<Switch>()) {
+      return isTailTransfer(sw);
+    }
+    return false;
+  }
+
+  template<typename CallType> void handleCall(CallType* call, bool isTail) {
+    // A call in tail position can have a type incompatible with the function's
+    // return type if it is dead code at the end of a block following an earlier
+    // unreachable instruction. Also avoid optimizing unreachable calls (e.g.
+    // calls with unreachable operands), since their callee return type may not
+    // match the caller return type.
+    if (call->isReturn || !isTail || call->type == Type::unreachable ||
+        !Type::isSubType(call->type, getFunction()->getResults())) {
+      return;
+    }
+    if (ehDepth > 0 &&
+        ShallowEffectAnalyzer(getPassOptions(), *getModule(), call).throws()) {
+      return;
+    }
+    call->isReturn = true;
+    call->finalize();
+    changed = true;
+  }
+
+  void visitBlock(Block* curr, bool isTail) {
+    if (isTail && curr->name.is()) {
+      tailBlocks.insert(curr->name);
+    }
+    bool nextIsTail = isTail;
+    for (int i = int(curr->list.size()) - 1; i >= 0; --i) {
+      bool itemIsTail = false;
+      if (i == int(curr->list.size()) - 1) {
+        itemIsTail = isTail;
+      } else if (getFunction()->getResults() == Type::none &&
+                 isTailTransfer(curr->list[i + 1], nextIsTail)) {
+        itemIsTail = true;
+      }
+      nextIsTail = itemIsTail;
+      push(&curr->list[i], itemIsTail);
+    }
+  }
+
+  void visitIf(If* curr, bool isTail) {
+    maybePush(&curr->ifFalse, isTail);
+    push(&curr->ifTrue, isTail);
+    push(&curr->condition, false);
+  }
+
+  void visitLoop(Loop* curr, bool isTail) { push(&curr->body, isTail); }
+
+  void visitBreak(Break* curr, bool isTail) {
+    bool valueIsTail = curr->value && isTailTransfer(curr, isTail);
+    maybePush(&curr->condition, false);
+    maybePush(&curr->value, valueIsTail);
+  }
+
+  void visitSwitch(Switch* curr, bool isTail) {
+    bool valueIsTail = curr->value && isTailTransfer(curr);
+    push(&curr->condition, false);
+    maybePush(&curr->value, valueIsTail);
+  }
+
+  void visitReturn(Return* curr, bool isTail) { maybePush(&curr->value, true); }
+
+  void visitTry(Try* curr, bool isTail) {
+    for (int i = int(curr->catchBodies.size()) - 1; i >= 0; --i) {
+      push(&curr->catchBodies[i], isTail);
+    }
+    // A try block that delegates directly to the caller does not catch any
+    // exceptions in this function; exceptions thrown in its body already unwind
+    // the frame to the caller just like a return_call would. All other try
+    // blocks (catch/catch_all or delegating to an outer try) establish a local
+    // handler that would be bypassed by return_call.
+    bool hasLocalHandler =
+      !curr->isDelegate() || curr->delegateTarget != DELEGATE_CALLER_TARGET;
+    if (hasLocalHandler) {
+      pushLeaveTry();
+    }
+    push(&curr->body, isTail);
+    if (hasLocalHandler) {
+      pushEnterTry();
+    }
+  }
+
+  void visitTryTable(TryTable* curr, bool isTail) {
+    bool hasLocalHandler = !curr->catchTags.empty();
+    if (hasLocalHandler) {
+      pushLeaveTry();
+    }
+    push(&curr->body, isTail);
+    if (hasLocalHandler) {
+      pushEnterTry();
+    }
+  }
+
+  void visitCall(Call* curr, bool isTail) {
+    handleCall(curr, isTail);
+    visitExpression(curr, false);
+  }
+
+  void visitCallIndirect(CallIndirect* curr, bool isTail) {
+    handleCall(curr, isTail);
+    visitExpression(curr, false);
+  }
+
+  void visitCallRef(CallRef* curr, bool isTail) {
+    handleCall(curr, isTail);
+    visitExpression(curr, false);
+  }
+
+  void doWalkFunction(Function* func) {
+    if (!getModule()->features.hasTailCall() || func->imported()) {
+      return;
+    }
+    tailBlocks.clear();
+    walk(func->body);
+    if (changed) {
+      ReFinalize().walkFunctionInModule(func, getModule());
+    }
+  }
+};
+
+} // anonymous namespace
+
+Pass* createTailCallPass() { return new TailCall(); }
+
+} // namespace wasm
diff --git a/src/passes/TranslateEH.cpp b/src/passes/TranslateEH.cpp
index 7e13ee53179..23d21e6e49e 100644
--- a/src/passes/TranslateEH.cpp
+++ b/src/passes/TranslateEH.cpp
@@ -720,7 +720,7 @@ struct TranslateToExnref : public WalkerPass<PostWalker<TranslateToExnref>> {
     // rethrows, we can assume the exnref we want to rethrow is located in that
     // exnref local at this point. We ensure this to happen when converting the
     // corresponding 'try' to 'try_table' by using catch_ref/catch_all_ref and
-    // assining the exnref to that local.
+    // assigning the exnref to that local.
     Builder builder(*getModule());
     Index exnrefLocal = *localAssigner->getExnrefLocal(curr->target);
     replaceCurrent(builder.makeThrowRef(
diff --git a/src/passes/TrapMode.cpp b/src/passes/TrapMode.cpp
deleted file mode 100644
index 18a016436eb..00000000000
--- a/src/passes/TrapMode.cpp
+++ /dev/null
@@ -1,347 +0,0 @@
-/*
- * Copyright 2017 WebAssembly Community Group participants
- *
- * 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.
- */
-
-//
-// Pass that supports potentially-trapping wasm operations.
-// For example, integer division traps when dividing by zero, so this pass
-// generates a check and replaces the result with zero in that case.
-//
-
-#include "asmjs/shared-constants.h"
-#include "ir/trapping.h"
-#include "pass.h"
-#include "support/mixed_arena.h"
-#include "support/name.h"
-#include "wasm-builder.h"
-#include "wasm-type.h"
-#include "wasm.h"
-
-namespace wasm {
-
-static const Name I64S_REM("i64s-rem");
-static const Name I64U_REM("i64u-rem");
-static const Name I64S_DIV("i64s-div");
-static const Name I64U_DIV("i64u-div");
-static const Name F64_TO_INT64("f64-to-int64");
-static const Name F64_TO_UINT64("f64-to-uint64");
-static const Name F32_TO_INT64("f32-to-int64");
-static const Name F32_TO_UINT64("f32-to-uint64");
-
-static Expression* ensureDouble(Expression* expr, MixedArena& allocator) {
-  if (expr->type == Type::f32) {
-    auto conv = allocator.alloc<Unary>();
-    conv->op = PromoteFloat32;
-    conv->value = expr;
-    conv->type = Type::f64;
-    return conv;
-  }
-  assert(expr->type == Type::f64);
-  return expr;
-}
-
-Name getBinaryFuncName(Binary* curr) {
-  switch (curr->op) {
-    case RemSInt32:
-      return I32S_REM;
-    case RemUInt32:
-      return I32U_REM;
-    case DivSInt32:
-      return I32S_DIV;
-    case DivUInt32:
-      return I32U_DIV;
-    case RemSInt64:
-      return I64S_REM;
-    case RemUInt64:
-      return I64U_REM;
-    case DivSInt64:
-      return I64S_DIV;
-    case DivUInt64:
-      return I64U_DIV;
-    default:
-      return Name();
-  }
-}
-
-Name getUnaryFuncName(Unary* curr) {
-  switch (curr->op) {
-    case TruncSFloat32ToInt32:
-      return F32_TO_INT;
-    case TruncUFloat32ToInt32:
-      return F32_TO_UINT;
-    case TruncSFloat32ToInt64:
-      return F32_TO_INT64;
-    case TruncUFloat32ToInt64:
-      return F32_TO_UINT64;
-    case TruncSFloat64ToInt32:
-      return F64_TO_INT;
-    case TruncUFloat64ToInt32:
-      return F64_TO_UINT;
-    case TruncSFloat64ToInt64:
-      return F64_TO_INT64;
-    case TruncUFloat64ToInt64:
-      return F64_TO_UINT64;
-    default:
-      return Name();
-  }
-}
-
-bool isTruncOpSigned(UnaryOp op) {
-  switch (op) {
-    case TruncUFloat32ToInt32:
-    case TruncUFloat32ToInt64:
-    case TruncUFloat64ToInt32:
-    case TruncUFloat64ToInt64:
-      return false;
-    default:
-      return true;
-  }
-}
-
-Function* generateBinaryFunc(Module& wasm, Binary* curr) {
-  BinaryOp op = curr->op;
-  Type type = curr->type;
-  bool isI64 = type == Type::i64;
-  Builder builder(wasm);
-  Expression* result = builder.makeBinary(
-    op, builder.makeLocalGet(0, type), builder.makeLocalGet(1, type));
-  BinaryOp divSIntOp = isI64 ? DivSInt64 : DivSInt32;
-  UnaryOp eqZOp = isI64 ? EqZInt64 : EqZInt32;
-  Literal minLit = isI64 ? Literal(std::numeric_limits<int64_t>::min())
-                         : Literal(std::numeric_limits<int32_t>::min());
-  Literal zeroLit = isI64 ? Literal(int64_t(0)) : Literal(int32_t(0));
-  if (op == divSIntOp) {
-    // guard against signed division overflow
-    BinaryOp eqOp = isI64 ? EqInt64 : EqInt32;
-    Literal negLit = isI64 ? Literal(int64_t(-1)) : Literal(int32_t(-1));
-    result = builder.makeIf(
-      builder.makeBinary(
-        AndInt32,
-        builder.makeBinary(
-          eqOp, builder.makeLocalGet(0, type), builder.makeConst(minLit)),
-        builder.makeBinary(
-          eqOp, builder.makeLocalGet(1, type), builder.makeConst(negLit))),
-      builder.makeConst(zeroLit),
-      result);
-  }
-  auto funcSig = Signature({type, type}, type);
-  auto func = Builder::makeFunction(
-    getBinaryFuncName(curr), Type(funcSig, NonNullable, Exact), {});
-  func->body =
-    builder.makeIf(builder.makeUnary(eqZOp, builder.makeLocalGet(1, type)),
-                   builder.makeConst(zeroLit),
-                   result);
-  // TODO: use unique_ptr properly and do not release ownership.
-  return func.release();
-}
-
-template<typename IntType, typename FloatType>
-void makeClampLimitLiterals(Literal& iMin, Literal& fMin, Literal& fMax) {
-  IntType minVal = std::numeric_limits<IntType>::min();
-  IntType maxVal = std::numeric_limits<IntType>::max();
-  iMin = Literal(minVal);
-  fMin = Literal(FloatType(minVal) - 1);
-  fMax = Literal(FloatType(maxVal) + 1);
-}
-
-Function* generateUnaryFunc(Module& wasm, Unary* curr) {
-  Type type = curr->value->type;
-  Type retType = curr->type;
-  UnaryOp truncOp = curr->op;
-  bool isF64 = type == Type::f64;
-
-  Builder builder(wasm);
-
-  BinaryOp leOp = isF64 ? LeFloat64 : LeFloat32;
-  BinaryOp geOp = isF64 ? GeFloat64 : GeFloat32;
-  BinaryOp neOp = isF64 ? NeFloat64 : NeFloat32;
-
-  Literal iMin, fMin, fMax;
-  switch (truncOp) {
-    case TruncSFloat32ToInt32:
-      makeClampLimitLiterals<int32_t, float>(iMin, fMin, fMax);
-      break;
-    case TruncUFloat32ToInt32:
-      makeClampLimitLiterals<uint32_t, float>(iMin, fMin, fMax);
-      break;
-    case TruncSFloat32ToInt64:
-      makeClampLimitLiterals<int64_t, float>(iMin, fMin, fMax);
-      break;
-    case TruncUFloat32ToInt64:
-      makeClampLimitLiterals<uint64_t, float>(iMin, fMin, fMax);
-      break;
-    case TruncSFloat64ToInt32:
-      makeClampLimitLiterals<int32_t, double>(iMin, fMin, fMax);
-      break;
-    case TruncUFloat64ToInt32:
-      makeClampLimitLiterals<uint32_t, double>(iMin, fMin, fMax);
-      break;
-    case TruncSFloat64ToInt64:
-      makeClampLimitLiterals<int64_t, double>(iMin, fMin, fMax);
-      break;
-    case TruncUFloat64ToInt64:
-      makeClampLimitLiterals<uint64_t, double>(iMin, fMin, fMax);
-      break;
-    default:
-      WASM_UNREACHABLE("unexpected op");
-  }
-
-  auto func =
-    Builder::makeFunction(getUnaryFuncName(curr),
-                          Type(Signature(type, retType), NonNullable, Exact),
-                          {});
-  func->body = builder.makeUnary(truncOp, builder.makeLocalGet(0, type));
-  // too small XXX this is different than asm.js, which does frem. here we
-  // clamp, which is much simpler/faster, and similar to native builds
-  func->body = builder.makeIf(builder.makeBinary(leOp,
-                                                 builder.makeLocalGet(0, type),
-                                                 builder.makeConst(fMin)),
-                              builder.makeConst(iMin),
-                              func->body);
-  // too big XXX see above
-  func->body = builder.makeIf(
-    builder.makeBinary(
-      geOp, builder.makeLocalGet(0, type), builder.makeConst(fMax)),
-    // NB: min here as well. anything out of range => to the min
-    builder.makeConst(iMin),
-    func->body);
-  // nan
-  func->body = builder.makeIf(
-    builder.makeBinary(
-      neOp, builder.makeLocalGet(0, type), builder.makeLocalGet(0, type)),
-    // NB: min here as well. anything invalid => to the min
-    builder.makeConst(iMin),
-    func->body);
-  // TODO: use unique_ptr properly and do not release ownership.
-  return func.release();
-}
-
-void ensureBinaryFunc(Binary* curr,
-                      Module& wasm,
-                      TrappingFunctionContainer& trappingFunctions) {
-  Name name = getBinaryFuncName(curr);
-  if (trappingFunctions.hasFunction(name)) {
-    return;
-  }
-  trappingFunctions.addFunction(generateBinaryFunc(wasm, curr));
-}
-
-void ensureUnaryFunc(Unary* curr,
-                     Module& wasm,
-                     TrappingFunctionContainer& trappingFunctions) {
-  Name name = getUnaryFuncName(curr);
-  if (trappingFunctions.hasFunction(name)) {
-    return;
-  }
-  trappingFunctions.addFunction(generateUnaryFunc(wasm, curr));
-}
-
-void ensureF64ToI64JSImport(TrappingFunctionContainer& trappingFunctions) {
-  if (trappingFunctions.hasImport(F64_TO_INT)) {
-    return;
-  }
-
-  // f64-to-int = asm2wasm.f64-to-int;
-  auto import = new Function;
-  import->name = F64_TO_INT;
-  import->module = ASM2WASM;
-  import->base = F64_TO_INT;
-  import->type = Type(Signature(Type::f64, Type::i32), NonNullable, Inexact);
-  trappingFunctions.addImport(import);
-}
-
-Expression* makeTrappingBinary(Binary* curr,
-                               TrappingFunctionContainer& trappingFunctions) {
-  Name name = getBinaryFuncName(curr);
-  if (!name.is() || trappingFunctions.getMode() == TrapMode::Allow) {
-    return curr;
-  }
-
-  // the wasm operation might trap if done over 0, so generate a safe call
-  Type type = curr->type;
-  Module& wasm = trappingFunctions.getModule();
-  Builder builder(wasm);
-  ensureBinaryFunc(curr, wasm, trappingFunctions);
-  return builder.makeCall(name, {curr->left, curr->right}, type);
-}
-
-Expression* makeTrappingUnary(Unary* curr,
-                              TrappingFunctionContainer& trappingFunctions) {
-  Name name = getUnaryFuncName(curr);
-  TrapMode mode = trappingFunctions.getMode();
-  if (!name.is() || mode == TrapMode::Allow) {
-    return curr;
-  }
-
-  Module& wasm = trappingFunctions.getModule();
-  Builder builder(wasm);
-  // WebAssembly traps on float-to-int overflows, but asm.js wouldn't, so we
-  // must do something We can handle this in one of two ways: clamping, which is
-  // fast, or JS, which is precisely like JS but in order to do that we do a
-  // slow ffi If i64, there is no "JS" way to handle this, as no i64s in JS, so
-  // always clamp if we don't allow traps asm.js doesn't have unsigned
-  // f64-to-int, so just use the signed one.
-  if (curr->type != Type::i64 && mode == TrapMode::JS) {
-    // WebAssembly traps on float-to-int overflows, but asm.js wouldn't, so we
-    // must emulate that
-    ensureF64ToI64JSImport(trappingFunctions);
-    Expression* f64Value = ensureDouble(curr->value, wasm.allocator);
-    return builder.makeCall(F64_TO_INT, {f64Value}, Type::i32);
-  }
-
-  ensureUnaryFunc(curr, wasm, trappingFunctions);
-  return builder.makeCall(name, {curr->value}, curr->type);
-}
-
-struct TrapModePass : public WalkerPass<PostWalker<TrapModePass>> {
-public:
-  // Needs to be non-parallel so that visitModule gets called after visiting
-  // each node in the module, so we can add the functions that we created.
-  bool isFunctionParallel() override { return false; }
-
-  TrapModePass(TrapMode mode) : mode(mode) { assert(mode != TrapMode::Allow); }
-
-  std::unique_ptr<Pass> create() override {
-    return std::make_unique<TrapModePass>(mode);
-  }
-
-  void visitUnary(Unary* curr) {
-    replaceCurrent(makeTrappingUnary(curr, *trappingFunctions));
-  }
-
-  void visitBinary(Binary* curr) {
-    replaceCurrent(makeTrappingBinary(curr, *trappingFunctions));
-  }
-
-  void visitModule(Module* curr) { trappingFunctions->addToModule(); }
-
-  void doWalkModule(Module* module) {
-    trappingFunctions =
-      std::make_unique<TrappingFunctionContainer>(mode, *module);
-    Super::doWalkModule(module);
-  }
-
-private:
-  TrapMode mode;
-  // Need to defer adding generated functions because adding functions while
-  // iterating over existing functions causes problems.
-  std::unique_ptr<TrappingFunctionContainer> trappingFunctions;
-};
-
-Pass* createTrapModeClamp() { return new TrapModePass(TrapMode::Clamp); }
-
-Pass* createTrapModeJS() { return new TrapModePass(TrapMode::JS); }
-
-} // namespace wasm
diff --git a/src/passes/TypeGeneralizing.cpp b/src/passes/TypeGeneralizing.cpp
index eebebf95f35..e907c2c4c8a 100644
--- a/src/passes/TypeGeneralizing.cpp
+++ b/src/passes/TypeGeneralizing.cpp
@@ -706,6 +706,8 @@ struct TransferFn : OverriddenVisitor<TransferFn> {
 
   void visitWaitqueueNotify(WaitqueueNotify* curr) { WASM_UNREACHABLE("TODO"); }
 
+  void visitPublish(Publish* curr) { WASM_UNREACHABLE("TODO"); }
+
   void visitArrayNew(ArrayNew* curr) {
     // We cannot yet generalize allocations. Push a requirement for the
     // reference type needed to initialize the array, if any.
diff --git a/src/passes/TypeRefining.cpp b/src/passes/TypeRefining.cpp
index 720233cf9ae..1d4fad7d85d 100644
--- a/src/passes/TypeRefining.cpp
+++ b/src/passes/TypeRefining.cpp
@@ -551,7 +551,12 @@ struct TypeRefining : public Pass {
       }
 
       void visitStructCmpxchg(StructCmpxchg* curr) {
-        if (curr->type == Type::unreachable) {
+        if (curr->ref->type == Type::unreachable) {
+          // Ignore unreachable code. Note that we check curr->ref, not curr,
+          // as curr may be unreachable because of another operand than the ref
+          // and the replacement value (the expected value may be the
+          // unreachable one). In that case, the replacement must still validate
+          // as if it were written, so we must fix it up below.
           return;
         }
         auto type = curr->ref->type.getHeapType();
@@ -563,6 +568,8 @@ struct TypeRefining : public Pass {
         curr->replacement = fixType(curr->replacement, fieldType);
       }
 
+      // TODO: visitStructWait
+
       bool refinalize = false;
 
       // Fix up a given value so it fits into the type the location it is
diff --git a/src/passes/pass.cpp b/src/passes/pass.cpp
index 970e3fddfb5..db7e769c505 100644
--- a/src/passes/pass.cpp
+++ b/src/passes/pass.cpp
@@ -303,7 +303,7 @@ void PassRegistry::registerPasses() {
   registerPass(
     "merge-blocks", "merges blocks to their parents", createMergeBlocksPass);
   registerPass("merge-similar-functions",
-               "merges similar functions when benefical",
+               "merges similar functions when beneficial",
                createMergeSimilarFunctionsPass);
   registerPass(
     "merge-locals", "merges locals when beneficial", createMergeLocalsPass);
@@ -423,6 +423,9 @@ void PassRegistry::registerPasses() {
   registerPass("remove-relaxed-simd",
                "replaces relaxed SIMD instructions with unreachable",
                createRemoveRelaxedSIMDPass);
+  registerPass("remove-empty-function-exports",
+               "removes exports of empty functions",
+               createRemoveEmptyFunctionExportsPass);
   registerPass("remove-exports",
                "removes exports using a wildcard",
                createRemoveExportsPass);
@@ -555,6 +558,9 @@ void PassRegistry::registerPasses() {
   registerPass("stack-check",
                "enforce limits on llvm's __stack_pointer global",
                createStackCheckPass);
+  registerPass("tail-call",
+               "convert calls in tail position to return calls",
+               createTailCallPass);
   registerPass("strip-debug",
                "strip debug info (including the names section)",
                createStripDebugPass);
@@ -575,12 +581,6 @@ void PassRegistry::registerPasses() {
   registerPass("translate-to-exnref",
                "translate old Phase 3 EH instructions to new ones with exnref",
                createTranslateToExnrefPass);
-  registerPass("trap-mode-clamp",
-               "replace trapping operations with clamping semantics",
-               createTrapModeClamp);
-  registerPass("trap-mode-js",
-               "replace trapping operations with js semantics",
-               createTrapModeJS);
   registerPass("tuple-optimization",
                "optimize trivial tuples away",
                createTupleOptimizationPass);
diff --git a/src/passes/passes.h b/src/passes/passes.h
index 86e506b44b8..8a27158ecb0 100644
--- a/src/passes/passes.h
+++ b/src/passes/passes.h
@@ -139,6 +139,7 @@ Pass* createPropagateGlobalsGloballyPass();
 Pass* createRandomizeBranchHintsPass();
 Pass* createRemoveNonJSOpsPass();
 Pass* createRemoveRelaxedSIMDPass();
+Pass* createRemoveEmptyFunctionExportsPass();
 Pass* createRemoveExportsPass();
 Pass* createRemoveImportsPass();
 Pass* createRemoveMemoryInitPass();
@@ -190,9 +191,8 @@ Pass* createStubUnsupportedJSOpsPass();
 Pass* createSSAifyPass();
 Pass* createSSAifyNoMergePass();
 Pass* createTable64LoweringPass();
+Pass* createTailCallPass();
 Pass* createTranslateToExnrefPass();
-Pass* createTrapModeClamp();
-Pass* createTrapModeJS();
 Pass* createTupleOptimizationPass();
 Pass* createTypeGeneralizingPass();
 Pass* createTypeRefiningPass();
diff --git a/src/support/command-line.cpp b/src/support/command-line.cpp
index 30db3f4377d..83ef17dbfa3 100644
--- a/src/support/command-line.cpp
+++ b/src/support/command-line.cpp
@@ -48,14 +48,18 @@ void printWrap(std::ostream& os, int leftPad, const std::string& content) {
         space = SCREEN_WIDTH - leftPad;
       }
       os << nextWord;
-      space -= nextWord.size() + 1;
-      if (space > 0) {
-        os << ' ';
-      }
+      space -= nextWord.size();
       nextWord.clear();
-      if (content[i] == '\n') {
-        os << '\n';
-        space = SCREEN_WIDTH - leftPad;
+      if (i < len) {
+        if (content[i] == ' ') {
+          if (space > 0) {
+            os << ' ';
+            space -= 1;
+          }
+        } else if (content[i] == '\n') {
+          os << '\n';
+          space = SCREEN_WIDTH - leftPad;
+        }
       }
     }
   }
diff --git a/src/support/file_lock.h b/src/support/file_lock.h
new file mode 100644
index 00000000000..9f42a69fff4
--- /dev/null
+++ b/src/support/file_lock.h
@@ -0,0 +1,59 @@
+/*
+ * Copyright 2026 WebAssembly Community Group participants
+ *
+ * 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.
+ */
+
+//
+// RAII file lock for cross-process synchronization.
+//
+
+#ifndef wasm_support_file_lock_h
+#define wasm_support_file_lock_h
+
+#include <string>
+
+#ifndef _WIN32
+#include <fcntl.h>
+#include <sys/file.h>
+#include <unistd.h>
+#endif
+
+namespace wasm {
+
+struct FileLock {
+#ifndef _WIN32
+  int fd = -1;
+  FileLock(const std::string& path) {
+    fd = open(path.c_str(), O_RDWR | O_CREAT, 0666);
+    if (fd >= 0) {
+      flock(fd, LOCK_EX);
+    }
+  }
+  ~FileLock() {
+    if (fd >= 0) {
+      flock(fd, LOCK_UN);
+      close(fd);
+    }
+  }
+#else
+  FileLock(const std::string&) {}
+#endif
+
+  FileLock(const FileLock&) = delete;
+  FileLock& operator=(const FileLock&) = delete;
+};
+
+} // namespace wasm
+
+#endif // wasm_support_file_lock_h
diff --git a/src/support/inplace_vector.h b/src/support/inplace_vector.h
index cebf6f112fb..5f0d3628ebb 100644
--- a/src/support/inplace_vector.h
+++ b/src/support/inplace_vector.h
@@ -154,7 +154,6 @@ template<typename T, size_t N> class inplace_vector {
     ConstIterator(const Iterator& other)
       : wasm::ParentIndexIterator<const inplace_vector<T, N>*, ConstIterator>{
           other.parent, other.index} {}
-    ConstIterator(const ConstIterator& other) = default;
 
     const T& operator*() const { return (*this->parent)[this->index]; }
     const T* operator->() const { return &(*this->parent)[this->index]; }
diff --git a/src/support/small_vector.h b/src/support/small_vector.h
index 6a7a6ec89ec..93c8899bc59 100644
--- a/src/support/small_vector.h
+++ b/src/support/small_vector.h
@@ -175,7 +175,6 @@ template<typename T, size_t N> class SmallVector {
 
     Iterator(SmallVector<T, N>* parent, size_t index)
       : ParentIndexIterator<SmallVector<T, N>*, Iterator>{parent, index} {}
-    Iterator(const Iterator& other) = default;
 
     T& operator*() const { return (*this->parent)[this->index]; }
   };
@@ -189,7 +188,6 @@ template<typename T, size_t N> class SmallVector {
     ConstIterator(const SmallVector<T, N>* parent, size_t index)
       : ParentIndexIterator<const SmallVector<T, N>*, ConstIterator>{parent,
                                                                      index} {}
-    ConstIterator(const ConstIterator& other) = default;
 
     const T& operator*() const { return (*this->parent)[this->index]; }
   };
diff --git a/src/tools/CMakeLists.txt b/src/tools/CMakeLists.txt
index 91fea46b1df..4a24d506ec0 100644
--- a/src/tools/CMakeLists.txt
+++ b/src/tools/CMakeLists.txt
@@ -1,6 +1,7 @@
 include_directories(fuzzing)
 FILE(GLOB fuzzing_HEADERS fuzzing/*h)
 set(fuzzing_SOURCES
+  fuzzing/fuzz-stats.cpp
   fuzzing/fuzzing.cpp
   fuzzing/heap-types.cpp
   fuzzing/parameters.cpp
diff --git a/src/tools/fuzzing/fuzz-stats.cpp b/src/tools/fuzzing/fuzz-stats.cpp
new file mode 100644
index 00000000000..7f25f38a112
--- /dev/null
+++ b/src/tools/fuzzing/fuzz-stats.cpp
@@ -0,0 +1,298 @@
+/*
+ * Copyright 2026 WebAssembly Community Group participants
+ *
+ * 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.
+ */
+
+#include "tools/fuzzing/fuzz-stats.h"
+#include "support/file_lock.h"
+
+#include <algorithm>
+#include <fstream>
+#include <iomanip>
+#include <iostream>
+#include <map>
+#include <mutex>
+#include <sstream>
+
+namespace wasm {
+
+namespace {
+
+std::string getStatsFilename() {
+  if (const char* env = getenv("BINARYEN_FUZZ_STATS")) {
+    if (env[0] != '\0') {
+      std::string str(env);
+      if (str == "1" || str == "true" || str == "on" || str == "yes") {
+        return "fuzz-stats.txt";
+      }
+      return str;
+    }
+  }
+  return "";
+}
+
+struct PatternStatsRecord {
+  uint64_t occurrences = 0;
+  uint64_t inModules = 0;
+  uint64_t inFunctions = 0;
+};
+
+std::mutex eventsMutex;
+std::map<std::string, std::map<int, uint64_t>> pendingEvents;
+
+void saveStats(bool hasModuleStats,
+               uint64_t numFunctions,
+               const std::map<std::string, uint64_t>* occurrences,
+               const std::map<std::string, uint64_t>* funcMatches) {
+  std::string filename = getStatsFilename();
+  if (filename.empty()) {
+    return;
+  }
+
+  std::map<std::string, std::map<int, uint64_t>> localEvents;
+  {
+    std::lock_guard<std::mutex> lock(eventsMutex);
+    localEvents.swap(pendingEvents);
+  }
+
+  if (!hasModuleStats && localEvents.empty()) {
+    return;
+  }
+
+  // Lock file for safe concurrent updates across processes.
+  FileLock lock(filename + ".lock");
+
+  // Read existing statistics from file if present.
+  uint64_t totalModules = 0;
+  uint64_t totalFunctions = 0;
+  std::map<std::string, PatternStatsRecord> statsMap;
+  std::map<std::string, std::map<int, uint64_t>> eventStatsMap;
+
+  enum class Section { None, Patterns, Events };
+
+  {
+    std::ifstream in(filename);
+    if (in.is_open()) {
+      std::string line;
+      Section section = Section::None;
+      std::string currentEvent;
+      while (std::getline(in, line)) {
+        if (!line.empty() && line.back() == '\r') {
+          line.pop_back();
+        }
+        if (line.empty() || line[0] == '#') {
+          continue;
+        }
+        if (line == "Patterns:") {
+          section = Section::Patterns;
+          continue;
+        }
+        if (line == "Events:") {
+          section = Section::Events;
+          currentEvent.clear();
+          continue;
+        }
+        if (section == Section::Events) {
+          if (line.rfind("    ", 0) == 0) {
+            std::stringstream ss(line);
+            int outcome = 0;
+            char colon = 0;
+            uint64_t count = 0;
+            if (!currentEvent.empty() && (ss >> outcome >> colon) &&
+                colon == ':' && (ss >> count)) {
+              eventStatsMap[currentEvent][outcome] = count;
+            }
+          } else if (line.rfind("  ", 0) == 0) {
+            currentEvent = line.substr(2);
+            if (!currentEvent.empty() && currentEvent.back() == ':') {
+              currentEvent.pop_back();
+            }
+          }
+          continue;
+        }
+
+        std::stringstream ss(line);
+        std::string key;
+        if (ss >> key) {
+          if (key == "Modules:") {
+            ss >> totalModules;
+          } else if (key == "Functions:") {
+            ss >> totalFunctions;
+          } else if (section == Section::Patterns) {
+            std::string name = key;
+            uint64_t occurrencesCount = 0;
+            std::string perModStr, perFuncStr;
+            uint64_t inMods = 0;
+            std::string pctModStr;
+            uint64_t inFuncs = 0;
+            std::string pctFuncStr;
+            if (ss >> occurrencesCount >> perModStr >> perFuncStr >> inMods >>
+                pctModStr >> inFuncs >> pctFuncStr) {
+              statsMap[name] = {occurrencesCount, inMods, inFuncs};
+            } else {
+              statsMap[name].occurrences = occurrencesCount;
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // Accumulate current run into overall statistics.
+  if (hasModuleStats) {
+    totalModules += 1;
+    totalFunctions += numFunctions;
+
+    if (occurrences && funcMatches) {
+      for (const auto& [name, count] : *occurrences) {
+        auto& record = statsMap[name];
+        record.occurrences += count;
+        record.inFunctions += funcMatches->at(name);
+        if (count > 0) {
+          record.inModules += 1;
+        }
+      }
+    }
+  }
+
+  for (const auto& [eventName, outcomes] : localEvents) {
+    for (const auto& [outcome, count] : outcomes) {
+      eventStatsMap[eventName][outcome] += count;
+    }
+  }
+
+  // Write updated statistics to a temporary file and atomically rename.
+  std::string tmpFilename = filename + ".tmp";
+  {
+    std::ofstream out(tmpFilename);
+    if (!out.is_open()) {
+      return;
+    }
+
+    out << "# Binaryen Fuzzing Statistics\n";
+    out << "Modules: " << totalModules << "\n";
+    out << "Functions: " << totalFunctions << "\n";
+
+    if (!statsMap.empty()) {
+      out << "\nPatterns:\n";
+      out << "# " << std::left << std::setw(30) << "Name" << std::right
+          << std::setw(12) << "Occurrences" << std::setw(14) << "Per Module"
+          << std::setw(14) << "Per Function" << std::setw(10) << "Modules"
+          << std::setw(12) << "% Modules" << std::setw(12) << "Functions"
+          << std::setw(14) << "% Functions"
+          << "\n";
+
+      for (const auto& [name, data] : statsMap) {
+        double perMod =
+          totalModules > 0 ? (double)data.occurrences / totalModules : 0.0;
+        double perFunc =
+          totalFunctions > 0 ? (double)data.occurrences / totalFunctions : 0.0;
+        double pctMod =
+          totalModules > 0 ? (100.0 * data.inModules) / totalModules : 0.0;
+        double pctFunc = totalFunctions > 0
+                           ? (100.0 * data.inFunctions) / totalFunctions
+                           : 0.0;
+
+        std::ostringstream pctModStream, pctFuncStream;
+        pctModStream << std::fixed << std::setprecision(2) << pctMod << "%";
+        pctFuncStream << std::fixed << std::setprecision(2) << pctFunc << "%";
+
+        out << "  " << std::left << std::setw(30) << name << std::right
+            << std::setw(12) << data.occurrences << std::setw(14) << std::fixed
+            << std::setprecision(4) << perMod << std::setw(14) << std::fixed
+            << std::setprecision(4) << perFunc << std::setw(10)
+            << data.inModules << std::setw(12) << pctModStream.str()
+            << std::setw(12) << data.inFunctions << std::setw(14)
+            << pctFuncStream.str() << "\n";
+      }
+    }
+
+    if (!eventStatsMap.empty()) {
+      out << "\nEvents:\n";
+      for (const auto& [eventName, outcomes] : eventStatsMap) {
+        uint64_t totalEventCount = 0;
+        for (const auto& [outcome, count] : outcomes) {
+          totalEventCount += count;
+        }
+        out << "  " << eventName << ":\n";
+        for (const auto& [outcome, count] : outcomes) {
+          double pct =
+            totalEventCount > 0 ? (100.0 * count) / totalEventCount : 0.0;
+          std::ostringstream pctStream;
+          pctStream << std::fixed << std::setprecision(2) << pct << "%";
+          out << "    " << std::left << std::setw(8)
+              << (std::to_string(outcome) + ":") << std::right << std::setw(12)
+              << count << " (" << std::setw(7) << pctStream.str() << ")\n";
+        }
+      }
+    }
+  }
+
+  rename(tmpFilename.c_str(), filename.c_str());
+
+  if (getenv("BINARYEN_FUZZ_STATS_VERBOSE")) {
+    std::cerr << "Fuzz stats updated in " << filename
+              << " (Total Modules: " << totalModules
+              << ", Total Functions: " << totalFunctions << ")\n";
+  }
+}
+
+struct EventFlusher {
+  ~EventFlusher() { saveStats(false, 0, nullptr, nullptr); }
+} eventFlusher;
+
+} // namespace
+
+namespace FuzzStats {
+
+bool isEnabled() {
+  static const bool enabled = !getStatsFilename().empty();
+  return enabled;
+}
+
+int recordEvent(const std::string& name, int outcome) {
+  if (!isEnabled()) {
+    return outcome;
+  }
+  std::lock_guard<std::mutex> lock(eventsMutex);
+  pendingEvents[name][outcome]++;
+  return outcome;
+}
+
+int recordEvent(const std::string& name,
+                const char* file,
+                int line,
+                int outcome) {
+  if (!isEnabled()) {
+    return outcome;
+  }
+  const char* filename = file;
+  for (const char* p = file; *p; ++p) {
+    if (*p == '/' || *p == '\\') {
+      filename = p + 1;
+    }
+  }
+  return recordEvent(name + " (" + filename + ":" + std::to_string(line) + ")",
+                     outcome);
+}
+
+void save(uint64_t numFunctions,
+          const std::map<std::string, uint64_t>& occurrences,
+          const std::map<std::string, uint64_t>& funcMatches) {
+  saveStats(true, numFunctions, &occurrences, &funcMatches);
+}
+
+} // namespace FuzzStats
+
+} // namespace wasm
diff --git a/src/tools/fuzzing/fuzz-stats.h b/src/tools/fuzzing/fuzz-stats.h
new file mode 100644
index 00000000000..c3de6106f86
--- /dev/null
+++ b/src/tools/fuzzing/fuzz-stats.h
@@ -0,0 +1,102 @@
+/*
+ * Copyright 2026 WebAssembly Community Group participants
+ *
+ * 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.
+ */
+
+#ifndef wasm_tools_fuzzing_fuzz_stats_h
+#define wasm_tools_fuzzing_fuzz_stats_h
+
+#include "wasm-traversal.h"
+
+#include <map>
+#include <string>
+
+namespace wasm {
+
+class Module;
+
+namespace FuzzStats {
+
+// Record the outcome of a random decision or event during fuzzing.
+// If statistics collection is not enabled (via BINARYEN_FUZZ_STATS), this does
+// nothing. Returns `outcome` so it can be used inline in expressions.
+int recordEvent(const std::string& name, int outcome);
+
+int recordEvent(const std::string& name,
+                const char* file,
+                int line,
+                int outcome);
+
+// Check whether statistics collection is enabled.
+bool isEnabled();
+
+// Save collected statistics to the stats file.
+void save(uint64_t numFunctions,
+          const std::map<std::string, uint64_t>& occurrences,
+          const std::map<std::string, uint64_t>& funcMatches);
+
+// CRTP base class for visitors that collect fuzzing pattern statistics.
+template<typename SubType>
+struct PatternCollectorBase : public PostWalker<SubType> {
+  // Counts within the current function: pattern name -> count
+  std::map<std::string, uint64_t> currentFuncCounts;
+
+  // Pattern stats for this module: pattern name -> total occurrences
+  std::map<std::string, uint64_t> occurrences;
+  // pattern name -> number of functions with >= 1 occurrence
+  std::map<std::string, uint64_t> funcMatches;
+  uint64_t numFunctions = 0;
+
+  void record(const std::string& name) { currentFuncCounts[name]++; }
+
+  void visitFunction(Function* func) {
+    if (func->imported() || !func->body) {
+      return;
+    }
+    numFunctions++;
+    for (const auto& [name, count] : currentFuncCounts) {
+      if (count > 0) {
+        occurrences[name] += count;
+        funcMatches[name]++;
+      }
+    }
+    currentFuncCounts.clear();
+  }
+
+  // Walk the module and save collected statistics if enabled.
+  void collect(Module& wasm) {
+    if (!isEnabled()) {
+      return;
+    }
+    for (const auto& func : wasm.functions) {
+      if (!func->imported() && func->body) {
+        this->walkFunction(func.get());
+      }
+    }
+    save(numFunctions, occurrences, funcMatches);
+  }
+};
+
+} // namespace FuzzStats
+
+using FuzzStats::recordEvent;
+
+#define RECORD_EVENT(name, outcome)                                            \
+  ::wasm::FuzzStats::recordEvent((name), __FILE__, __LINE__, (outcome))
+
+#define RECORD_FUZZ_EVENT(name, outcome) RECORD_EVENT(name, outcome)
+
+} // namespace wasm
+
+#endif // wasm_tools_fuzzing_fuzz_stats_h
diff --git a/src/tools/fuzzing/fuzzing.cpp b/src/tools/fuzzing/fuzzing.cpp
index c28026bca07..d906b706c5f 100644
--- a/src/tools/fuzzing/fuzzing.cpp
+++ b/src/tools/fuzzing/fuzzing.cpp
@@ -31,10 +31,51 @@
 #include "wasm-io.h"
 #include "wasm-type.h"
 
+#include "tools/fuzzing/fuzz-stats.h"
+
 namespace wasm {
 
 namespace {
 
+struct FuzzStatsCollector
+  : public FuzzStats::PatternCollectorBase<FuzzStatsCollector> {
+  // Collect the occurrences of various cast instructions. Casts are
+  // particularly important for fuzzing. Meant as a sample for running
+  // experiments collecting other interesting patterns.
+  void visitBrOn(BrOn* curr) {
+    switch (curr->op) {
+      case BrOnNull:
+        record("br_on_null");
+        break;
+      case BrOnNonNull:
+        record("br_on_non_null");
+        break;
+      case BrOnCast:
+        record("br_on_cast");
+        break;
+      case BrOnCastFail:
+        record("br_on_cast_fail");
+        break;
+      case BrOnCastDescEq:
+        record("br_on_cast_desc_eq");
+        break;
+      case BrOnCastDescEqFail:
+        record("br_on_cast_desc_eq_fail");
+        break;
+    }
+  }
+
+  void visitRefCast(RefCast* curr) {
+    if (curr->desc) {
+      record("ref_cast_desc_eq");
+    } else {
+      record("ref_cast");
+    }
+  }
+
+  void visitRefTest(RefTest* curr) { record("ref_test"); }
+};
+
 std::vector<Type> getLoggableTypes(const FeatureSet& features) {
   std::vector<Type> loggableTypes = {
     Type::i32, Type::i64, Type::f32, Type::f64};
@@ -418,6 +459,8 @@ void TranslateToFuzzReader::build() {
   if (againstJS) {
     mutateJSBoundary();
   }
+
+  FuzzStatsCollector().collect(wasm);
 }
 
 void TranslateToFuzzReader::setupMemory() {
@@ -968,12 +1011,12 @@ void TranslateToFuzzReader::finalizeTable() {
       }
     }
 
-    // The code above raises table->initial to a size large enough to accomodate
-    // all of its segments, with the intention of avoiding a trap during
-    // startup. However a single segment of (say) size 4GB would have a table of
-    // that size, which will use a lot of memory and execute very slowly, so we
-    // prefer in the fuzzer to trap on such a thing. To achieve that, set a
-    // reasonable limit for the maximum table size.
+    // The code above raises table->initial to a size large enough to
+    // accommodate all of its segments, with the intention of avoiding a trap
+    // during startup. However a single segment of (say) size 4GB would have a
+    // table of that size, which will use a lot of memory and execute very
+    // slowly, so we prefer in the fuzzer to trap on such a thing. To achieve
+    // that, set a reasonable limit for the maximum table size.
     //
     // This also avoids an issue that arises from table->initial being an
     // Address (64 bits) but Table::kMaxSize being an Index (32 bits), as a
diff --git a/src/tools/fuzzing/heap-types.cpp b/src/tools/fuzzing/heap-types.cpp
index a808befc679..ee9ce65df3c 100644
--- a/src/tools/fuzzing/heap-types.cpp
+++ b/src/tools/fuzzing/heap-types.cpp
@@ -286,8 +286,14 @@ struct HeapTypeGeneratorImpl {
   void populateTypes() {
     // Create the heap types.
     for (; index < builder.size(); ++index) {
-      // Types without nontrivial subtypes may be marked final.
-      builder[index].setOpen(subtypeIndices[index].size() > 1 || rand.oneIn(2));
+      // Types without nontrivial subtypes may be marked final. Descriptors
+      // must have the same finality as their described types.
+      if (describedIndices[index]) {
+        builder[index].setOpen(builder[*describedIndices[index]].isOpen());
+      } else {
+        builder[index].setOpen(subtypeIndices[index].size() > 1 ||
+                               rand.oneIn(2));
+      }
       auto kind = typeKinds[index];
       auto share = HeapType(builder[index]).getShared();
       bool isDesc = describedIndices[index].has_value();
diff --git a/src/tools/optimization-options.h b/src/tools/optimization-options.h
index 1e089f0b8c8..a43c92c3fe7 100644
--- a/src/tools/optimization-options.h
+++ b/src/tools/optimization-options.h
@@ -306,7 +306,8 @@ struct OptimizationOptions : public ToolOptions {
       .add(
         "--fast-math",
         "-ffm",
-        "Optimize floats without handling corner cases of NaNs and rounding",
+        "Optimize floats without handling corner cases of NaNs, rounding, and "
+        "negative zero",
         OptimizationOptionsCategory,
         Options::Arguments::Zero,
         [this](Options*, const std::string&) { passOptions.fastMath = true; })
diff --git a/src/tools/wasm-ctor-eval.cpp b/src/tools/wasm-ctor-eval.cpp
index f5b05c98220..a948f258c65 100644
--- a/src/tools/wasm-ctor-eval.cpp
+++ b/src/tools/wasm-ctor-eval.cpp
@@ -912,7 +912,6 @@ struct CtorEvalExternalInterface : EvallingModuleRunner::ExternalInterface {
     } else {
       // This is the first usage of this data. Generate a struct.new /
       // array.new for it.
-      auto& values = data->values;
       std::vector<Expression*> args;
 
       // The initial values for this allocation may themselves be GC
@@ -934,8 +933,8 @@ struct CtorEvalExternalInterface : EvallingModuleRunner::ExternalInterface {
         definingGlobals[data] = DefiningGlobalInfo{definingGlobalName, type};
       }
 
-      for (auto& value : values) {
-        auto* serialized = getSerialization(value);
+      for (size_t i = 0; i < value.getNumElements(); i++) {
+        auto* serialized = getSerialization(value.getElement(i));
         if (!serialized) {
           return nullptr;
         }
@@ -1218,26 +1217,29 @@ EvalCtorOutcome evalCtor(EvallingModuleRunner& instance,
 
       if (flow.breakTo == RETURN_CALL_FLOW) {
         // The return-called function is stored in the last value.
-        func = wasm.getFunction(flow.values.back().getFunc());
+        auto* nextFunc = wasm.getFunction(flow.values.back().getFunc());
         flow.values.pop_back();
-        params = std::move(flow.values);
+        auto nextParams = std::move(flow.values);
 
         // Serialize the arguments for the new function and save the module
         // state in case we fail to eval the new function.
-        localExprs.clear();
-        for (auto& param : params) {
+        std::vector<Expression*> nextLocalExprs;
+        for (auto& param : nextParams) {
           auto* serialized = interface.getSerialization(param);
           if (!serialized) {
             break;
           }
-          localExprs.push_back(serialized);
+          nextLocalExprs.push_back(serialized);
         }
-        if (localExprs.size() < params.size()) {
+        if (nextLocalExprs.size() < nextParams.size()) {
           if (!quiet) {
             std::cout << "  ...stopping due to non-serializable param\n";
           }
           break;
         }
+        func = nextFunc;
+        params = std::move(nextParams);
+        localExprs = std::move(nextLocalExprs);
         interface.applyToModule();
         goto start_eval;
       }
diff --git a/src/tools/wasm-emscripten-finalize.cpp b/src/tools/wasm-emscripten-finalize.cpp
index 59d3a0eae40..6b58a82d1c9 100644
--- a/src/tools/wasm-emscripten-finalize.cpp
+++ b/src/tools/wasm-emscripten-finalize.cpp
@@ -22,7 +22,6 @@
 #include <exception>
 
 #include "abi/js.h"
-#include "ir/trapping.h"
 #include "support/colors.h"
 #include "support/debug.h"
 #include "support/file.h"
diff --git a/src/tools/wasm-fuzz-lattices.cpp b/src/tools/wasm-fuzz-lattices.cpp
index 7ca385633fa..d1409578609 100644
--- a/src/tools/wasm-fuzz-lattices.cpp
+++ b/src/tools/wasm-fuzz-lattices.cpp
@@ -574,7 +574,7 @@ void checkLatticeProperties(Random& rand, bool verbose) {
                   << LatticeComparisonNames[ij]
                   << "\nSecond to third relation: "
                   << LatticeComparisonNames[jk]
-                  << "\nFirst to thrid relation: " << LatticeComparisonNames[ik]
+                  << "\nFirst to third relation: " << LatticeComparisonNames[ik]
                   << "\n";
         }
       }
diff --git a/src/tools/wasm-opt.cpp b/src/tools/wasm-opt.cpp
index 94d72181cac..f5e010fcb2f 100644
--- a/src/tools/wasm-opt.cpp
+++ b/src/tools/wasm-opt.cpp
@@ -110,7 +110,7 @@ For more on how to optimize effectively, see
 
   https://github.com/WebAssembly/binaryen/wiki/Optimizer-Cookbook
   https://github.com/WebAssembly/binaryen/wiki/GC-Optimization-Guidebook
-                            )");
+)");
 
   options
     .add("--output",
diff --git a/src/tools/wasm-reduce/wasm-reduce.cpp b/src/tools/wasm-reduce/wasm-reduce.cpp
index 42eb113bd34..3b53aadca60 100644
--- a/src/tools/wasm-reduce/wasm-reduce.cpp
+++ b/src/tools/wasm-reduce/wasm-reduce.cpp
@@ -1396,7 +1396,7 @@ Comparison to creduce:
 More documentation can be found at
 
   https://github.com/WebAssembly/binaryen/wiki/Fuzzing#reducing
-                      )");
+)");
   options
     .add("--command",
          "-cmd",
diff --git a/src/tools/wasm-split/instrumenter.cpp b/src/tools/wasm-split/instrumenter.cpp
index 56fa67373e3..0277ffcfe2b 100644
--- a/src/tools/wasm-split/instrumenter.cpp
+++ b/src/tools/wasm-split/instrumenter.cpp
@@ -178,7 +178,7 @@ void Instrumenter::instrumentFuncs() {
 // instrumented and the module that is being split are different. The timestamps
 // are non-zero for functions that were called during the instrumented run and 0
 // otherwise. Functions with smaller non-zero timestamps were called earlier in
-// the instrumented run than funtions with larger timestamps.
+// the instrumented run than functions with larger timestamps.
 
 void Instrumenter::addProfileExport(size_t numFuncs) {
   // Calculate the size of the profile:
diff --git a/src/wasm-binary.h b/src/wasm-binary.h
index 73d9075211e..eb53aab8703 100644
--- a/src/wasm-binary.h
+++ b/src/wasm-binary.h
@@ -725,6 +725,7 @@ enum ASTNodes {
   StructWait = 0x05,
   WaitqueueNotify = 0x06,
   WaitqueueNew = 0x07,
+  Publish = 0x0f,
 
   I32AtomicLoad = 0x10,
   I64AtomicLoad = 0x11,
diff --git a/src/wasm-builder.h b/src/wasm-builder.h
index 3b4cbb2d7ef..56db519263a 100644
--- a/src/wasm-builder.h
+++ b/src/wasm-builder.h
@@ -1474,6 +1474,13 @@ class Builder {
     return ret;
   }
 
+  Publish* makePublish(Expression* ref) {
+    auto* ret = wasm.allocator.alloc<Publish>();
+    ret->ref = ref;
+    ret->finalize();
+    return ret;
+  }
+
   // Additional helpers
 
   Drop* makeDrop(Expression* value) {
@@ -1504,7 +1511,7 @@ class Builder {
       // The string is already WTF-16, but we need to convert from `Literals` to
       // actual string.
       std::stringstream wtf16;
-      for (auto c : value.getGCData()->values) {
+      for (auto c : value.getGCData()->getLiterals()) {
         auto u = c.getInteger();
         assert(u < 0x10000);
         wtf16 << uint8_t(u & 0xFF);
diff --git a/src/wasm-delegations-fields.def b/src/wasm-delegations-fields.def
index d2de547c3d3..5933428c3a8 100644
--- a/src/wasm-delegations-fields.def
+++ b/src/wasm-delegations-fields.def
@@ -938,6 +938,10 @@ DELEGATE_FIELD_CHILD(WaitqueueNotify, count)
 DELEGATE_FIELD_CHILD(WaitqueueNotify, waitqueue)
 DELEGATE_FIELD_CASE_END(WaitqueueNotify)
 
+DELEGATE_FIELD_CASE_START(Publish)
+DELEGATE_FIELD_CHILD(Publish, ref)
+DELEGATE_FIELD_CASE_END(Publish)
+
 DELEGATE_FIELD_CASE_START(WideIntAddSub)
 DELEGATE_FIELD_INT(WideIntAddSub, op)
 DELEGATE_FIELD_CHILD(WideIntAddSub, rightHigh)
diff --git a/src/wasm-delegations.def b/src/wasm-delegations.def
index 56d1be65a15..ef911fd46e8 100644
--- a/src/wasm-delegations.def
+++ b/src/wasm-delegations.def
@@ -122,5 +122,6 @@ DELEGATE(WideIntAddSub);
 DELEGATE(WideIntMul);
 DELEGATE(WaitqueueNew);
 DELEGATE(WaitqueueNotify);
+DELEGATE(Publish);
 
 #undef DELEGATE
diff --git a/src/wasm-interpreter.h b/src/wasm-interpreter.h
index 08a1405ba22..6842005e8bb 100644
--- a/src/wasm-interpreter.h
+++ b/src/wasm-interpreter.h
@@ -370,10 +370,11 @@ class ExpressionRunner : public OverriddenVisitor<SubType, Flow> {
   // this function in LSan.
   //
   // This consumes the input |data| entirely.
-  Literal makeGCData(Literals&& data,
+  template<typename T>
+  Literal makeGCData(T&& data,
                      Type type,
                      Literal desc = Literal::makeNull(HeapType::none)) {
-    auto allocation = std::make_shared<GCData>(std::move(data), desc);
+    auto allocation = std::make_shared<GCData>(std::forward<T>(data), desc);
 #if __has_feature(leak_sanitizer) || __has_feature(address_sanitizer)
     // GC data with cycles will leak, since shared_ptrs do not handle cycles.
     // Binaryen is generally not used in long-running programs so we just ignore
@@ -384,6 +385,23 @@ class ExpressionRunner : public OverriddenVisitor<SubType, Flow> {
     return Literal(allocation, type.getHeapType());
   }
 
+  Literal makeGCArray(Type type,
+                      size_t num,
+                      Literal desc = Literal::makeNull(HeapType::none)) {
+    auto heapType = type.getHeapType();
+    const auto& element = heapType.getArray().element;
+    if (element.type.isRef()) {
+      Literals data(num);
+      auto zero = Literal::makeZero(element.type);
+      for (size_t i = 0; i < num; ++i) {
+        data[i] = zero;
+      }
+      return makeGCData(std::move(data), type, desc);
+    }
+    size_t elemBytes = element.getByteSize();
+    return makeGCData(std::vector<uint8_t>(num * elemBytes, 0), type, desc);
+  }
+
   // Same as makeGCData but for ExnData.
   Literal makeExnData(Tag* tag, const Literals& payload) {
     auto allocation = std::make_shared<ExnData>(tag, payload);
@@ -393,20 +411,6 @@ class ExpressionRunner : public OverriddenVisitor<SubType, Flow> {
     return Literal(allocation);
   }
 
-  template<typename T>
-  void writeBytes(T value, int numBytes, size_t index, Literals& values) {
-    if constexpr (std::is_same_v<T, std::array<uint8_t, 16>>) {
-      for (int i = 0; i < numBytes; ++i) {
-        values[index + i] = Literal(static_cast<int32_t>(value[i]));
-      }
-    } else {
-      for (int i = 0; i < numBytes; ++i) {
-        values[index + i] =
-          Literal(static_cast<int32_t>((value >> (i * 8)) & 0xff));
-      }
-    }
-  }
-
   static Literal applyRMW(AtomicRMWOp op, Literal lhs, Literal rhs) {
     switch (op) {
       case RMWAdd:
@@ -2276,7 +2280,8 @@ class ExpressionRunner : public OverriddenVisitor<SubType, Flow> {
       trap("null ref");
     }
     auto field = curr->ref->type.getHeapType().getStruct().fields[curr->index];
-    return extendForPacking(data->values[curr->index], field, curr->signed_);
+    return extendForPacking(
+      data->getLiterals()[curr->index], field, curr->signed_);
   }
   Flow visitStructSet(StructSet* curr) {
     VISIT(ref, curr->ref)
@@ -2286,7 +2291,7 @@ class ExpressionRunner : public OverriddenVisitor<SubType, Flow> {
       trap("null ref");
     }
     auto field = curr->ref->type.getHeapType().getStruct().fields[curr->index];
-    data->values[curr->index] =
+    data->getLiterals()[curr->index] =
       truncateForPacking(value.getSingleValue(), field);
     return Flow();
   }
@@ -2298,7 +2303,7 @@ class ExpressionRunner : public OverriddenVisitor<SubType, Flow> {
     if (!data) {
       trap("null ref");
     }
-    auto& field = data->values[curr->index];
+    auto& field = data->getLiterals()[curr->index];
     auto oldVal = field;
     field = applyRMW(curr->op, oldVal, value.getSingleValue());
     return oldVal;
@@ -2312,7 +2317,7 @@ class ExpressionRunner : public OverriddenVisitor<SubType, Flow> {
     if (!data) {
       trap("null ref");
     }
-    auto& field = data->values[curr->index];
+    auto& field = data->getLiterals()[curr->index];
     auto oldVal = field;
     if (field == expected.getSingleValue()) {
       field = replacement.getSingleValue();
@@ -2337,7 +2342,7 @@ class ExpressionRunner : public OverriddenVisitor<SubType, Flow> {
     if (!waitqueue.getSingleValue().getGCData()) {
       trap("null ref");
     }
-    auto& field = data->values[curr->index];
+    auto& field = data->getLiterals()[curr->index];
     if (field != expected.getSingleValue()) {
       return Literal(int32_t{1}); // not equal
     }
@@ -2354,7 +2359,7 @@ class ExpressionRunner : public OverriddenVisitor<SubType, Flow> {
   }
 
   Flow visitWaitqueueNew(WaitqueueNew* curr) {
-    return self()->makeGCData({},
+    return self()->makeGCData(Literals{},
                               Type(HeapTypes::sharedWaitqueue, NonNullable));
   }
 
@@ -2370,6 +2375,11 @@ class ExpressionRunner : public OverriddenVisitor<SubType, Flow> {
     return Literal(int32_t{0}); // none woken up
   }
 
+  Flow visitPublish(Publish* curr) {
+    VISIT(ref, curr->ref)
+    return ref;
+  }
+
   // Arbitrary deterministic limit on size. If we need to allocate a Literals
   // vector that takes around 1-2GB of memory then we are likely to hit memory
   // limits on 32-bit machines, and in particular on wasm32 VMs that do not
@@ -2389,26 +2399,18 @@ class ExpressionRunner : public OverriddenVisitor<SubType, Flow> {
       assert(init.breaking());
       return init;
     }
-    auto heapType = curr->type.getHeapType();
-    const auto& element = heapType.getArray().element;
     Index num = size.getSingleValue().geti32();
     if (num >= DataLimit) {
       hostLimit("allocation failure");
     }
-    Literals data(num);
-    if (curr->isWithDefault()) {
-      auto zero = Literal::makeZero(element.type);
-      for (Index i = 0; i < num; i++) {
-        data[i] = zero;
-      }
-    } else {
-      auto field = curr->type.getHeapType().getArray().element;
-      auto value = truncateForPacking(init.getSingleValue(), field);
+    auto ret = makeGCArray(curr->type, num);
+    if (!curr->isWithDefault()) {
+      Literal val = init.getSingleValue();
       for (Index i = 0; i < num; i++) {
-        data[i] = value;
+        ret.setElement(i, val);
       }
     }
-    return makeGCData(std::move(data), curr->type);
+    return ret;
   }
   Flow visitArrayNewData(ArrayNewData* curr) { WASM_UNREACHABLE("unimp"); }
   Flow visitArrayNewElem(ArrayNewElem* curr) { WASM_UNREACHABLE("unimp"); }
@@ -2425,91 +2427,105 @@ class ExpressionRunner : public OverriddenVisitor<SubType, Flow> {
       }
       WASM_UNREACHABLE("unreachable but no unreachable child");
     }
-    auto heapType = curr->type.getHeapType();
-    auto field = heapType.getArray().element;
-    Literals data(num);
+    auto ret = makeGCArray(curr->type, num);
     for (Index i = 0; i < num; i++) {
       VISIT(value, curr->values[i])
-      data[i] = truncateForPacking(value.getSingleValue(), field);
+      ret.setElement(i, value.getSingleValue());
     }
-    return makeGCData(std::move(data), curr->type);
+    return ret;
   }
   Flow visitArrayGet(ArrayGet* curr) {
     VISIT(ref, curr->ref)
     VISIT(index, curr->index)
-    auto data = ref.getSingleValue().getGCData();
-    if (!data) {
+    auto refVal = ref.getSingleValue();
+    if (refVal.isNull()) {
       trap("null ref");
     }
     Index i = index.getSingleValue().geti32();
-    if (i >= data->values.size()) {
+    if (i >= refVal.getNumElements()) {
       trap("array oob");
     }
-    auto field = curr->ref->type.getHeapType().getArray().element;
-    return extendForPacking(data->values[i], field, curr->signed_);
+    return refVal.getElement(i, curr->signed_);
   }
   Flow visitArraySet(ArraySet* curr) {
     VISIT(ref, curr->ref)
     VISIT(index, curr->index)
     VISIT(value, curr->value)
-    auto data = ref.getSingleValue().getGCData();
-    if (!data) {
+    auto refVal = ref.getSingleValue();
+    if (refVal.isNull()) {
       trap("null ref");
     }
     Index i = index.getSingleValue().geti32();
-    if (i >= data->values.size()) {
+    if (i >= refVal.getNumElements()) {
       trap("array oob");
     }
-    auto field = curr->ref->type.getHeapType().getArray().element;
-    data->values[i] = truncateForPacking(value.getSingleValue(), field);
+    refVal.setElement(i, value.getSingleValue());
     return Flow();
   }
   Flow visitArrayLoad(ArrayLoad* curr) {
     VISIT(ref, curr->ref)
     VISIT(index, curr->index)
-    auto data = ref.getSingleValue().getGCData();
-    if (!data) {
+    auto refVal = ref.getSingleValue();
+    if (refVal.isNull()) {
       trap("null ref");
     }
     Index i = index.getSingleValue().geti32();
-    size_t size = data->values.size();
+    size_t size = refVal.getRawBytes().size();
     if (i >= size || curr->bytes > (size - i)) {
       trap("array oob");
     }
-    uint64_t val = 0;
-    for (unsigned b = 0; b < curr->bytes; ++b) {
-      val |= static_cast<uint64_t>(data->values[i + b].geti32()) << (b * 8);
-    }
+    const uint8_t* p = &refVal.getRawBytes()[i];
     switch (curr->type.getBasic()) {
       case Type::i32: {
-        int32_t sval = static_cast<int32_t>(val);
-        if (curr->signed_) {
-          if (curr->bytes == 1) {
-            sval = static_cast<int32_t>(static_cast<int8_t>(sval));
-          } else if (curr->bytes == 2) {
-            sval = static_cast<int32_t>(static_cast<int16_t>(sval));
-          }
+        switch (curr->bytes) {
+          case 1:
+            return curr->signed_ ? Literal((int32_t)Bits::readLE<int8_t>(p))
+                                 : Literal((int32_t)Bits::readLE<uint8_t>(p));
+          case 2:
+            return curr->signed_ ? Literal((int32_t)Bits::readLE<int16_t>(p))
+                                 : Literal((int32_t)Bits::readLE<uint16_t>(p));
+          case 4:
+            return Literal(Bits::readLE<int32_t>(p));
+          default:
+            WASM_UNREACHABLE("invalid size");
         }
-        return Literal(sval);
       }
       case Type::i64: {
-        int64_t sval = static_cast<int64_t>(val);
-        if (curr->signed_) {
-          if (curr->bytes == 1) {
-            sval = static_cast<int64_t>(static_cast<int8_t>(sval));
-          } else if (curr->bytes == 2) {
-            sval = static_cast<int64_t>(static_cast<int16_t>(sval));
-          } else if (curr->bytes == 4) {
-            sval = static_cast<int64_t>(static_cast<int32_t>(sval));
-          }
+        switch (curr->bytes) {
+          case 1:
+            return curr->signed_ ? Literal((int64_t)Bits::readLE<int8_t>(p))
+                                 : Literal((int64_t)Bits::readLE<uint8_t>(p));
+          case 2:
+            return curr->signed_ ? Literal((int64_t)Bits::readLE<int16_t>(p))
+                                 : Literal((int64_t)Bits::readLE<uint16_t>(p));
+          case 4:
+            return curr->signed_ ? Literal((int64_t)Bits::readLE<int32_t>(p))
+                                 : Literal((int64_t)Bits::readLE<uint32_t>(p));
+          case 8:
+            return Literal(Bits::readLE<int64_t>(p));
+          default:
+            WASM_UNREACHABLE("invalid size");
         }
-        return Literal(sval);
       }
       case Type::f32: {
-        return Literal(bit_cast<float>(static_cast<int32_t>(val)));
+        switch (curr->bytes) {
+          case 2:
+            return Literal(bit_cast<int32_t>(fp16_ieee_to_fp32_value(
+                             Bits::readLE<uint16_t>(p))))
+              .castToF32();
+          case 4:
+            return Literal(Bits::readLE<uint32_t>(p)).castToF32();
+          default:
+            WASM_UNREACHABLE("invalid size");
+        }
       }
       case Type::f64: {
-        return Literal(bit_cast<double>(static_cast<int64_t>(val)));
+        assert(curr->bytes == 8);
+        return Literal(Bits::readLE<uint64_t>(p)).castToF64();
+      }
+      case Type::v128: {
+        assert(curr->bytes == 16);
+        return Literal(p);
       }
       default:
         WASM_UNREACHABLE("invalid type");
@@ -2520,55 +2536,36 @@ class ExpressionRunner : public OverriddenVisitor<SubType, Flow> {
     VISIT(ref, curr->ref)
     VISIT(index, curr->index)
     VISIT(value, curr->value)
-    auto data = ref.getSingleValue().getGCData();
-    if (!data) {
+    auto refVal = ref.getSingleValue();
+    if (refVal.isNull()) {
       trap("null ref");
     }
 
     Index i = index.getSingleValue().geti32();
-    size_t size = data->values.size();
+    size_t size = refVal.getRawBytes().size();
     // Use subtraction to avoid overflow.
     if (i >= size || curr->bytes > (size - i)) {
       trap("array oob");
     }
-    switch (curr->value->type.getBasic()) {
-      case Type::i32:
-        writeBytes(
-          value.getSingleValue().geti32(), curr->bytes, i, data->values);
-        break;
-      case Type::i64:
-        writeBytes(
-          value.getSingleValue().geti64(), curr->bytes, i, data->values);
-        break;
-      case Type::f32:
-        writeBytes(value.getSingleValue().reinterpreti32(),
-                   curr->bytes,
-                   i,
-                   data->values);
-        break;
-      case Type::f64:
-        writeBytes(value.getSingleValue().reinterpreti64(),
-                   curr->bytes,
-                   i,
-                   data->values);
-        break;
-      case Type::v128:
-        writeBytes(
-          value.getSingleValue().getv128(), curr->bytes, i, data->values);
-        break;
-      case Type::none:
-      case Type::unreachable:
-        WASM_UNREACHABLE("unimp basic type");
+    uint8_t* p = &refVal.getRawBytes()[i];
+    auto val = value.getSingleValue();
+    if (curr->value->type == Type::f32 && curr->bytes == 2) {
+      float f32 = bit_cast<float>(val.reinterpreti32());
+      Bits::writeLE<uint16_t>(fp16_ieee_from_fp32_value(f32), p);
+    } else {
+      uint8_t buf[16];
+      val.getBits(buf);
+      memcpy(p, buf, curr->bytes);
     }
     return Flow();
   }
   Flow visitArrayLen(ArrayLen* curr) {
     VISIT(ref, curr->ref)
-    auto data = ref.getSingleValue().getGCData();
-    if (!data) {
+    auto refVal = ref.getSingleValue();
+    if (refVal.isNull()) {
       trap("null ref");
     }
-    return Literal(int32_t(data->values.size()));
+    return Literal(int32_t(refVal.getNumElements()));
   }
   Flow visitArrayCopy(ArrayCopy* curr) {
     VISIT(destRef, curr->destRef)
@@ -2576,30 +2573,42 @@ class ExpressionRunner : public OverriddenVisitor<SubType, Flow> {
     VISIT(srcRef, curr->srcRef)
     VISIT(srcIndex, curr->srcIndex)
     VISIT(length, curr->length)
-    auto destData = destRef.getSingleValue().getGCData();
-    if (!destData) {
+    auto destVal = destRef.getSingleValue();
+    if (destVal.isNull()) {
       trap("null ref");
     }
-    auto srcData = srcRef.getSingleValue().getGCData();
-    if (!srcData) {
+    auto srcVal = srcRef.getSingleValue();
+    if (srcVal.isNull()) {
       trap("null ref");
     }
-    size_t destVal = destIndex.getSingleValue().getUnsigned();
-    size_t srcVal = srcIndex.getSingleValue().getUnsigned();
+    size_t destIdx = destIndex.getSingleValue().getUnsigned();
+    size_t srcIdx = srcIndex.getSingleValue().getUnsigned();
     size_t lengthVal = length.getSingleValue().getUnsigned();
-    if (destVal + lengthVal > destData->values.size()) {
+    if (destIdx + lengthVal > destVal.getNumElements()) {
       trap("oob");
     }
-    if (srcVal + lengthVal > srcData->values.size()) {
+    if (srcIdx + lengthVal > srcVal.getNumElements()) {
       trap("oob");
     }
+    // Fast path: bulk copy raw byte buffers directly with memmove rather than
+    // extracting and setting elements one-by-one via Literals.
+    if (destVal.isRawBytes() && srcVal.isRawBytes()) {
+      if (lengthVal > 0) {
+        auto elemSize =
+          destVal.type.getHeapType().getArray().element.getByteSize();
+        memmove(&destVal.getRawBytes()[destIdx * elemSize],
+                &srcVal.getRawBytes()[srcIdx * elemSize],
+                lengthVal * elemSize);
+      }
+      return Flow();
+    }
     std::vector<Literal> copied;
     copied.resize(lengthVal);
     for (size_t i = 0; i < lengthVal; i++) {
-      copied[i] = srcData->values[srcVal + i];
+      copied[i] = srcVal.getElement(srcIdx + i);
     }
     for (size_t i = 0; i < lengthVal; i++) {
-      destData->values[destVal + i] = copied[i];
+      destVal.setElement(destIdx + i, copied[i]);
     }
     return Flow();
   }
@@ -2608,24 +2617,21 @@ class ExpressionRunner : public OverriddenVisitor<SubType, Flow> {
     VISIT(index, curr->index)
     VISIT(value, curr->value)
     VISIT(size, curr->size)
-    auto data = ref.getSingleValue().getGCData();
-    if (!data) {
+    auto refVal = ref.getSingleValue();
+    if (refVal.isNull()) {
       trap("null ref");
     }
     size_t indexVal = index.getSingleValue().getUnsigned();
     Literal fillVal = value.getSingleValue();
     size_t sizeVal = size.getSingleValue().getUnsigned();
 
-    auto field = curr->ref->type.getHeapType().getArray().element;
-    fillVal = truncateForPacking(fillVal, field);
-
-    size_t arraySize = data->values.size();
+    size_t arraySize = refVal.getNumElements();
     if (indexVal > arraySize || sizeVal > arraySize ||
         indexVal + sizeVal > arraySize || indexVal + sizeVal < indexVal) {
       trap("out of bounds array access in array.fill");
     }
     for (size_t i = 0; i < sizeVal; ++i) {
-      data->values[indexVal + i] = fillVal;
+      refVal.setElement(indexVal + i, fillVal);
     }
     return {};
   }
@@ -2635,17 +2641,17 @@ class ExpressionRunner : public OverriddenVisitor<SubType, Flow> {
     VISIT(ref, curr->ref)
     VISIT(index, curr->index)
     VISIT(value, curr->value)
-    auto data = ref.getSingleValue().getGCData();
-    if (!data) {
+    auto refVal = ref.getSingleValue();
+    if (refVal.isNull()) {
       trap("null ref");
     }
     size_t indexVal = index.getSingleValue().getUnsigned();
-    if (indexVal >= data->values.size()) {
+    if (indexVal >= refVal.getNumElements()) {
       trap("array oob");
     }
-    auto& field = data->values[indexVal];
-    auto oldVal = field;
-    field = applyRMW(curr->op, oldVal, value.getSingleValue());
+    auto oldVal = refVal.getElement(indexVal);
+    refVal.setElement(indexVal,
+                      applyRMW(curr->op, oldVal, value.getSingleValue()));
     return oldVal;
   }
 
@@ -2654,18 +2660,17 @@ class ExpressionRunner : public OverriddenVisitor<SubType, Flow> {
     VISIT(index, curr->index)
     VISIT(expected, curr->expected)
     VISIT(replacement, curr->replacement)
-    auto data = ref.getSingleValue().getGCData();
-    if (!data) {
+    auto refVal = ref.getSingleValue();
+    if (refVal.isNull()) {
       trap("null ref");
     }
     size_t indexVal = index.getSingleValue().getUnsigned();
-    if (indexVal >= data->values.size()) {
+    if (indexVal >= refVal.getNumElements()) {
       trap("array oob");
     }
-    auto& field = data->values[indexVal];
-    auto oldVal = field;
-    if (field == expected.getSingleValue()) {
-      field = replacement.getSingleValue();
+    auto oldVal = refVal.getElement(indexVal);
+    if (oldVal == expected.getSingleValue()) {
+      refVal.setElement(indexVal, replacement.getSingleValue());
     }
     return oldVal;
   }
@@ -2691,22 +2696,21 @@ class ExpressionRunner : public OverriddenVisitor<SubType, Flow> {
       case StringNewWTF16Array: {
         VISIT(start, curr->start)
         VISIT(end, curr->end)
-        auto ptrData = ptr.getSingleValue().getGCData();
-        if (!ptrData) {
+        auto ptrVal = ptr.getSingleValue();
+        if (ptrVal.isNull()) {
           trap("null ref");
         }
-        const auto& ptrDataValues = ptrData->values;
+        size_t arrayLen = ptrVal.getNumElements();
         size_t startVal = start.getSingleValue().getUnsigned();
         size_t endVal = end.getSingleValue().getUnsigned();
-        if (startVal > ptrDataValues.size() || endVal > ptrDataValues.size() ||
-            endVal < startVal) {
+        if (startVal > arrayLen || endVal > arrayLen || endVal < startVal) {
           trap("array oob");
         }
         Literals contents;
         if (endVal > startVal) {
           contents.reserve(endVal - startVal);
           for (size_t i = startVal; i < endVal; i++) {
-            contents.push_back(ptrDataValues[i]);
+            contents.push_back(ptrVal.getElement(i));
           }
         }
         return makeGCData(std::move(contents), curr->type);
@@ -2743,7 +2747,7 @@ class ExpressionRunner : public OverriddenVisitor<SubType, Flow> {
       trap("null ref");
     }
 
-    return Literal(int32_t(data->values.size()));
+    return Literal(int32_t(data->getLiterals().size()));
   }
   Flow visitStringConcat(StringConcat* curr) {
     VISIT(flow, curr->left)
@@ -2756,17 +2760,19 @@ class ExpressionRunner : public OverriddenVisitor<SubType, Flow> {
       trap("null ref");
     }
 
-    auto totalSize = leftData->values.size() + rightData->values.size();
+    auto totalSize =
+      leftData->getLiterals().size() + rightData->getLiterals().size();
     if (totalSize >= DataLimit) {
       hostLimit("allocation failure");
     }
 
     Literals contents;
-    contents.reserve(leftData->values.size() + rightData->values.size());
-    for (Literal& l : leftData->values) {
+    contents.reserve(leftData->getLiterals().size() +
+                     rightData->getLiterals().size());
+    for (Literal& l : leftData->getLiterals()) {
       contents.push_back(l);
     }
-    for (Literal& l : rightData->values) {
+    for (Literal& l : rightData->getLiterals()) {
       contents.push_back(l);
     }
 
@@ -2783,24 +2789,24 @@ class ExpressionRunner : public OverriddenVisitor<SubType, Flow> {
     VISIT(start, curr->start)
 
     auto strData = str.getSingleValue().getGCData();
-    auto arrayData = array.getSingleValue().getGCData();
-    if (!strData || !arrayData) {
+    auto arrayVal = array.getSingleValue();
+    if (!strData || arrayVal.isNull()) {
       trap("null ref");
     }
     auto startVal = start.getSingleValue().getUnsigned();
-    auto& strValues = strData->values;
-    auto& arrayValues = arrayData->values;
+    auto& strValues = strData->getLiterals();
+    size_t arrayLen = arrayVal.getNumElements();
     size_t end;
     if (std::ckd_add<size_t>(&end, startVal, strValues.size()) ||
-        end > arrayValues.size()) {
+        end > arrayLen) {
       trap("oob");
     }
 
     for (Index i = 0; i < strValues.size(); i++) {
-      arrayValues[startVal + i] = strValues[i];
+      arrayVal.setElement(startVal + i, strValues[i]);
     }
 
-    return Literal(int32_t(strData->values.size()));
+    return Literal(int32_t(strValues.size()));
   }
   Flow visitStringEq(StringEq* curr) {
     VISIT(flow, curr->left)
@@ -2813,17 +2819,17 @@ class ExpressionRunner : public OverriddenVisitor<SubType, Flow> {
     switch (curr->op) {
       case StringEqEqual: {
         // They are equal if both are null, or both are non-null and equal.
-        result =
-          (!leftData && !rightData) ||
-          (leftData && rightData && leftData->values == rightData->values);
+        result = (!leftData && !rightData) ||
+                 (leftData && rightData &&
+                  leftData->getLiterals() == rightData->getLiterals());
         break;
       }
       case StringEqCompare: {
         if (!leftData || !rightData) {
           trap("null ref");
         }
-        auto& leftValues = leftData->values;
-        auto& rightValues = rightData->values;
+        auto& leftValues = leftData->getLiterals();
+        auto& rightValues = rightData->getLiterals();
         Index i = 0;
         while (1) {
           if (i == leftValues.size() && i == rightValues.size()) {
@@ -2873,7 +2879,7 @@ class ExpressionRunner : public OverriddenVisitor<SubType, Flow> {
     if (!data) {
       trap("null ref");
     }
-    auto& values = data->values;
+    auto& values = data->getLiterals();
     Index i = pos.getSingleValue().geti32();
     if (i >= values.size()) {
       trap("string oob");
@@ -2890,7 +2896,7 @@ class ExpressionRunner : public OverriddenVisitor<SubType, Flow> {
     if (!refData) {
       trap("null ref");
     }
-    auto& refValues = refData->values;
+    auto& refValues = refData->getLiterals();
     auto startVal = start.getSingleValue().getUnsigned();
     auto endVal = end.getSingleValue().getUnsigned();
     endVal = std::min<size_t>(endVal, refValues.size());
@@ -2950,22 +2956,6 @@ class ExpressionRunner : public OverriddenVisitor<SubType, Flow> {
     }
     return value;
   }
-
-  Literal makeFromMemory(void* p, Field field) {
-    switch (field.packedType) {
-      case Field::NotPacked:
-        return Literal::makeFromMemory(p, field.type);
-      case Field::i8: {
-        return truncateForPacking(Literal(int32_t(Bits::readLE<int8_t>(p))),
-                                  field);
-      }
-      case Field::i16: {
-        return truncateForPacking(Literal(int32_t(Bits::readLE<int16_t>(p))),
-                                  field);
-      }
-    }
-    WASM_UNREACHABLE("unexpected type");
-  }
 };
 
 // Execute a suspected constant expression (precompute and C-API).
@@ -3111,6 +3101,7 @@ class ConstantExpressionRunner : public ExpressionRunner<SubType> {
   Flow visitWaitqueueNotify(WaitqueueNotify* curr) {
     return Flow(NONCONSTANT_FLOW);
   }
+  Flow visitPublish(Publish* curr) { return Flow(NONCONSTANT_FLOW); }
   Flow visitSIMDLoad(SIMDLoad* curr) { return Flow(NONCONSTANT_FLOW); }
   Flow visitSIMDLoadSplat(SIMDLoad* curr) { return Flow(NONCONSTANT_FLOW); }
   Flow visitSIMDLoadExtend(SIMDLoad* curr) { return Flow(NONCONSTANT_FLOW); }
@@ -4736,7 +4727,6 @@ class ModuleRunnerBase : public ExpressionRunner<SubType> {
 
     auto heapType = curr->type.getHeapType();
     const auto& element = heapType.getArray().element;
-    Literals contents;
 
     const auto& seg = *wasm.getDataSegment(curr->segment);
     auto elemBytes = element.getByteSize();
@@ -4751,10 +4741,9 @@ class ModuleRunnerBase : public ExpressionRunner<SubType> {
     if (droppedDataSegments.contains(curr->segment) && end > 0) {
       trap("dropped segment access in array.new_data");
     }
-    contents.reserve(size);
-    for (Index i = offset; i < end; i += elemBytes) {
-      auto addr = (void*)&seg.data[i];
-      contents.push_back(this->makeFromMemory(addr, element));
+    std::vector<uint8_t> contents(size * elemBytes);
+    if (size > 0) {
+      memcpy(contents.data(), &seg.data[offset], size * elemBytes);
     }
 
 #pragma GCC diagnostic pop
@@ -4790,15 +4779,15 @@ class ModuleRunnerBase : public ExpressionRunner<SubType> {
     VISIT(index, curr->index)
     VISIT(offset, curr->offset)
     VISIT(size, curr->size)
-    auto data = ref.getSingleValue().getGCData();
-    if (!data) {
+    auto refVal = ref.getSingleValue();
+    if (refVal.isNull()) {
       trap("null ref");
     }
     size_t indexVal = index.getSingleValue().getUnsigned();
     size_t offsetVal = offset.getSingleValue().getUnsigned();
     size_t sizeVal = size.getSingleValue().getUnsigned();
 
-    size_t arraySize = data->values.size();
+    size_t arraySize = refVal.getNumElements();
     if ((uint64_t)indexVal + sizeVal > arraySize) {
       trap("out of bounds array access in array.init");
     }
@@ -4816,9 +4805,11 @@ class ModuleRunnerBase : public ExpressionRunner<SubType> {
         droppedDataSegments.contains(curr->segment)) {
       trap("out of bounds segment access in array.init_data");
     }
-    for (size_t i = 0; i < sizeVal; i++) {
-      void* addr = (void*)&seg->data[offsetVal + i * elemSize];
-      data->values[indexVal + i] = this->makeFromMemory(addr, elem);
+    assert(refVal.isRawBytes());
+    if (sizeVal > 0) {
+      memcpy(&refVal.getRawBytes()[indexVal * elemSize],
+             &seg->data[offsetVal],
+             sizeVal * elemSize);
     }
     return {};
   }
@@ -4827,15 +4818,15 @@ class ModuleRunnerBase : public ExpressionRunner<SubType> {
     VISIT(index, curr->index)
     VISIT(offset, curr->offset)
     VISIT(size, curr->size)
-    auto data = ref.getSingleValue().getGCData();
-    if (!data) {
+    auto refVal = ref.getSingleValue();
+    if (refVal.isNull()) {
       trap("null ref");
     }
     size_t indexVal = index.getSingleValue().getUnsigned();
     size_t offsetVal = offset.getSingleValue().getUnsigned();
     size_t sizeVal = size.getSingleValue().getUnsigned();
 
-    size_t arraySize = data->values.size();
+    size_t arraySize = refVal.getNumElements();
     if ((uint64_t)indexVal + sizeVal > arraySize) {
       trap("out of bounds array access in array.init");
     }
@@ -4855,7 +4846,8 @@ class ModuleRunnerBase : public ExpressionRunner<SubType> {
       // of references in the table! ArrayNew suffers the same problem.
       // Fixing it will require changing how we represent segments, at least
       // in the interpreter.
-      data->values[indexVal + i] = self()->visit(seg->data[i]).getSingleValue();
+      refVal.setElement(indexVal + i,
+                        self()->visit(seg->data[i]).getSingleValue());
     }
     return {};
   }
@@ -5150,6 +5142,9 @@ class ModuleRunnerBase : public ExpressionRunner<SubType> {
         } else {
           // resume_throw_ref
           contData->exception = arguments[0];
+          if (contData->exception.isNull()) {
+            trap("null ref");
+          }
         }
       }
 
diff --git a/src/wasm-ir-builder.h b/src/wasm-ir-builder.h
index 6b68c27b686..a5f3ccdb9ad 100644
--- a/src/wasm-ir-builder.h
+++ b/src/wasm-ir-builder.h
@@ -260,6 +260,7 @@ class IRBuilder : public UnifiedExpressionVisitor<IRBuilder, Result<>> {
   Result<> makeStructWait(HeapType type, Index index);
   Result<> makeWaitqueueNew();
   Result<> makeWaitqueueNotify();
+  Result<> makePublish();
   Result<> makeArrayNew(HeapType type);
   Result<> makeArrayNewDefault(HeapType type);
   Result<> makeArrayNewData(HeapType type, Name data);
diff --git a/src/wasm-type.h b/src/wasm-type.h
index ee4a2dcc2fc..639185e9a6d 100644
--- a/src/wasm-type.h
+++ b/src/wasm-type.h
@@ -910,6 +910,7 @@ struct TypeBuilder {
   void createRecGroup(size_t i, size_t length);
 
   void setOpen(size_t i, bool open = true);
+  bool isOpen(size_t i) const;
   void setShared(size_t i, Shareability share = Shared);
 
   enum class ErrorReasonKind {
@@ -947,6 +948,8 @@ struct TypeBuilder {
     InvalidUnsharedDescribes,
     // The custom descriptors feature is missing.
     RequiresCustomDescriptors,
+    // The descriptor and described types have mismatched finality.
+    MismatchedDescriptorFinality,
     // Two rec groups with different shapes would have the same shapes after
     // the binary writer generalizes refined types that use disabled features.
     RecGroupCollision,
@@ -1036,6 +1039,7 @@ struct TypeBuilder {
       builder.setOpen(index, open);
       return *this;
     }
+    bool isOpen() const { return builder.isOpen(index); }
     Entry& setShared(Shareability share = Shared) {
       builder.setShared(index, share);
       return *this;
diff --git a/src/wasm.h b/src/wasm.h
index a94e36cad6d..3007b07f7f4 100644
--- a/src/wasm.h
+++ b/src/wasm.h
@@ -673,6 +673,9 @@ enum WideIntMulOp {
 
 class Expression {
 public:
+  // The type of the expression: its *output*, not necessarily its input(s)
+  Type type = Type::none;
+
   enum Id : uint8_t {
     InvalidId = 0,
     BlockId,
@@ -783,12 +786,15 @@ class Expression {
     WideIntMulId,
     WaitqueueNewId,
     WaitqueueNotifyId,
+    PublishId,
     NumExpressionIds
   };
-  Id _id;
 
-  // the type of the expression: its *output*, not necessarily its input(s)
-  Type type = Type::none;
+  // Placing this *after* the Type allows tail-padding reuse on some ABIs: the
+  // ID is only 1 byte, leaving lots of padding on 64-bit systems, which
+  // derived classes can sometimes reuse (if they have a suitable field up
+  // front; the classes below are sorted to optimize that).
+  Id _id;
 
   Expression(Id id) : _id(id) {}
 
@@ -947,9 +953,9 @@ class Call : public SpecificExpression<Expression::CallId> {
 public:
   Call(MixedArena& allocator) : operands(allocator) {}
 
+  bool isReturn = false;
   ExpressionList operands;
   Name target;
-  bool isReturn = false;
 
   void finalize();
 };
@@ -957,11 +963,12 @@ class Call : public SpecificExpression<Expression::CallId> {
 class CallIndirect : public SpecificExpression<Expression::CallIndirectId> {
 public:
   CallIndirect(MixedArena& allocator) : operands(allocator) {}
+
+  bool isReturn = false;
   HeapType heapType;
   ExpressionList operands;
   Expression* target;
   Name table;
-  bool isReturn = false;
 
   void finalize();
 };
@@ -1015,11 +1022,12 @@ class Load : public SpecificExpression<Expression::LoadId> {
 
   uint8_t bytes;
   bool signed_ = false;
+  MemoryOrder order = MemoryOrder::Unordered;
+
   Address offset;
   Address align;
   Expression* ptr;
   Name memory;
-  MemoryOrder order = MemoryOrder::Unordered;
 
   bool isAtomic() const { return order != MemoryOrder::Unordered; }
 
@@ -1034,13 +1042,14 @@ class Store : public SpecificExpression<Expression::StoreId> {
   Store(MixedArena& allocator) : Store() {}
 
   uint8_t bytes;
+  MemoryOrder order = MemoryOrder::Unordered;
+
   Address offset;
   Address align;
   Expression* ptr;
   Expression* value;
   Type valueType;
   Name memory;
-  MemoryOrder order;
 
   bool isAtomic() const { return order != MemoryOrder::Unordered; }
 
@@ -1053,12 +1062,12 @@ class AtomicRMW : public SpecificExpression<Expression::AtomicRMWId> {
   AtomicRMW(MixedArena& allocator) : AtomicRMW() {}
 
   AtomicRMWOp op;
+  MemoryOrder order = MemoryOrder::SeqCst;
   uint8_t bytes;
   Address offset;
   Expression* ptr;
   Expression* value;
   Name memory;
-  MemoryOrder order = MemoryOrder::SeqCst;
 
   void finalize();
 };
@@ -1069,12 +1078,12 @@ class AtomicCmpxchg : public SpecificExpression<Expression::AtomicCmpxchgId> {
   AtomicCmpxchg(MixedArena& allocator) : AtomicCmpxchg() {}
 
   uint8_t bytes;
+  MemoryOrder order = MemoryOrder::SeqCst;
   Address offset;
   Expression* ptr;
   Expression* expected;
   Expression* replacement;
   Name memory;
-  MemoryOrder order = MemoryOrder::SeqCst;
 
   void finalize();
 };
@@ -1126,9 +1135,9 @@ class SIMDExtract : public SpecificExpression<Expression::SIMDExtractId> {
   SIMDExtract() = default;
   SIMDExtract(MixedArena& allocator) : SIMDExtract() {}
 
+  uint8_t index;
   SIMDExtractOp op;
   Expression* vec;
-  uint8_t index;
 
   void finalize();
 };
@@ -1138,9 +1147,9 @@ class SIMDReplace : public SpecificExpression<Expression::SIMDReplaceId> {
   SIMDReplace() = default;
   SIMDReplace(MixedArena& allocator) : SIMDReplace() {}
 
+  uint8_t index;
   SIMDReplaceOp op;
   Expression* vec;
-  uint8_t index;
   Expression* value;
 
   void finalize();
@@ -1634,8 +1643,8 @@ class TupleExtract : public SpecificExpression<Expression::TupleExtractId> {
   TupleExtract() = default;
   TupleExtract(MixedArena& allocator) {}
 
-  Expression* tuple;
   Index index;
+  Expression* tuple;
 
   void finalize();
 };
@@ -1655,8 +1664,8 @@ class I31Get : public SpecificExpression<Expression::I31GetId> {
   I31Get() = default;
   I31Get(MixedArena& allocator) {}
 
-  Expression* i31;
   bool signed_ = false;
+  Expression* i31;
 
   void finalize();
 };
@@ -1664,9 +1673,10 @@ class I31Get : public SpecificExpression<Expression::I31GetId> {
 class CallRef : public SpecificExpression<Expression::CallRefId> {
 public:
   CallRef(MixedArena& allocator) : operands(allocator) {}
+
+  bool isReturn = false;
   ExpressionList operands;
   Expression* target;
-  bool isReturn = false;
 
   void finalize();
 };
@@ -1754,11 +1764,11 @@ class StructGet : public SpecificExpression<Expression::StructGetId> {
   StructGet() = default;
   StructGet(MixedArena& allocator) {}
 
-  Index index;
-  Expression* ref;
   // Packed fields have a sign.
   bool signed_ = false;
   MemoryOrder order = MemoryOrder::Unordered;
+  Index index;
+  Expression* ref;
 
   bool isAtomic() const { return order != MemoryOrder::Unordered; }
 
@@ -1770,10 +1780,10 @@ class StructSet : public SpecificExpression<Expression::StructSetId> {
   StructSet() = default;
   StructSet(MixedArena& allocator) {}
 
+  MemoryOrder order = MemoryOrder::Unordered;
   Index index;
   Expression* ref;
   Expression* value;
-  MemoryOrder order = MemoryOrder::Unordered;
 
   bool isAtomic() const { return order != MemoryOrder::Unordered; }
 
@@ -1786,10 +1796,10 @@ class StructRMW : public SpecificExpression<Expression::StructRMWId> {
   StructRMW(MixedArena& allocator) {}
 
   AtomicRMWOp op;
+  MemoryOrder order;
   Index index;
   Expression* ref;
   Expression* value;
-  MemoryOrder order;
 
   void finalize();
 };
@@ -1799,11 +1809,11 @@ class StructCmpxchg : public SpecificExpression<Expression::StructCmpxchgId> {
   StructCmpxchg() = default;
   StructCmpxchg(MixedArena& allocator) {}
 
+  MemoryOrder order;
   Index index;
   Expression* ref;
   Expression* expected;
   Expression* replacement;
-  MemoryOrder order;
 
   void finalize();
 };
@@ -1842,6 +1852,16 @@ class WaitqueueNotify
   void finalize();
 };
 
+class Publish : public SpecificExpression<Expression::PublishId> {
+public:
+  Publish() = default;
+  Publish(MixedArena& allocator) : Publish() {}
+
+  Expression* ref;
+
+  void finalize();
+};
+
 class ArrayNew : public SpecificExpression<Expression::ArrayNewId> {
 public:
   ArrayNew() = default;
@@ -1896,11 +1916,11 @@ class ArrayGet : public SpecificExpression<Expression::ArrayGetId> {
   ArrayGet() = default;
   ArrayGet(MixedArena& allocator) {}
 
-  Expression* ref;
-  Expression* index;
   // Packed fields have a sign.
   bool signed_ = false;
   MemoryOrder order = MemoryOrder::Unordered;
+  Expression* ref;
+  Expression* index;
 
   bool isAtomic() const { return order != MemoryOrder::Unordered; }
 
@@ -1912,10 +1932,10 @@ class ArraySet : public SpecificExpression<Expression::ArraySetId> {
   ArraySet() = default;
   ArraySet(MixedArena& allocator) {}
 
+  MemoryOrder order = MemoryOrder::Unordered;
   Expression* ref;
   Expression* index;
   Expression* value;
-  MemoryOrder order = MemoryOrder::Unordered;
 
   bool isAtomic() const { return order != MemoryOrder::Unordered; }
 
@@ -2022,11 +2042,11 @@ class ArrayRMW : public SpecificExpression<Expression::ArrayRMWId> {
   ArrayRMW() = default;
   ArrayRMW(MixedArena& allocator) {}
 
+  MemoryOrder order;
   AtomicRMWOp op;
   Expression* ref;
   Expression* index;
   Expression* value;
-  MemoryOrder order;
 
   void finalize();
 };
@@ -2036,11 +2056,11 @@ class ArrayCmpxchg : public SpecificExpression<Expression::ArrayCmpxchgId> {
   ArrayCmpxchg() = default;
   ArrayCmpxchg(MixedArena& allocator) {}
 
+  MemoryOrder order;
   Expression* ref;
   Expression* index;
   Expression* expected;
   Expression* replacement;
-  MemoryOrder order;
 
   void finalize();
 };
diff --git a/src/wasm/literal.cpp b/src/wasm/literal.cpp
index a037fef99e6..272cc5a6404 100644
--- a/src/wasm/literal.cpp
+++ b/src/wasm/literal.cpp
@@ -314,7 +314,7 @@ Literal Literal::makeNegOne(Type type) {
   return makeFromInt32(-1, type);
 }
 
-Literal Literal::makeFromMemory(void* p, Type type) {
+Literal Literal::makeFromMemory(const void* p, Type type) {
   assert(type.isNumber());
   switch (type.getBasic()) {
     case Type::i32: {
@@ -499,7 +499,7 @@ bool Literal::operator==(const Literal& other) const {
       return *funcData == *other.funcData;
     }
     if (type.isString()) {
-      return gcData->values == other.gcData->values;
+      return gcData->getLiterals() == other.gcData->getLiterals();
     }
     if (type.isData()) {
       return gcData == other.gcData;
@@ -775,8 +775,8 @@ std::ostream& operator<<(std::ostream& o, Literal literal) {
           break;
         case HeapType::any: {
           auto data = literal.getGCData();
-          assert(data->values.size() == 1);
-          o << "internalized " << literal.getGCData()->values[0];
+          assert(data->getLiterals().size() == 1);
+          o << "internalized " << data->getLiterals()[0];
           break;
         }
         case HeapType::ext: {
@@ -806,7 +806,7 @@ std::ostream& operator<<(std::ostream& o, Literal literal) {
             o << "string(";
             // Convert WTF-16 literals to WTF-16 string.
             std::stringstream wtf16;
-            for (auto c : data->values) {
+            for (auto c : data->getLiterals()) {
               auto u = c.getInteger();
               assert(u < 0x10000);
               wtf16 << uint8_t(u & 0xFF);
@@ -844,9 +844,15 @@ std::ostream& operator<<(std::ostream& o, Literal literal) {
       assert(literal.isData());
       auto data = literal.getGCData();
       assert(data);
-      o << "[ref " << literal.type.getHeapType() << ' ' << data->values;
+      o << "[ref " << literal.type.getHeapType() << ' ';
+      for (size_t i = 0; i < literal.getNumElements(); i++) {
+        if (i > 0) {
+          o << ' ';
+        }
+        o << literal.getElement(i);
+      }
       if (!data->desc.isNull()) {
-        if (!data->values.empty()) {
+        if (literal.getNumElements() > 0) {
           o << ", ";
         }
         o << "desc=" << data->desc;
@@ -3102,8 +3108,8 @@ Literal Literal::externalize() const {
   }
   if (heapType.isMaybeShared(HeapType::any)) {
     // This is an internalized externref or string; just unwrap it.
-    assert(gcData->values.size() == 1);
-    return gcData->values[0];
+    assert(gcData->getLiterals().size() == 1);
+    return gcData->getLiterals()[0];
   }
   // This is an internal reference. Wrap it.
   auto ext = HeapTypes::ext.getBasic(heapType.getShared());
@@ -3124,8 +3130,8 @@ Literal Literal::internalize() const {
     return Literal(std::make_shared<GCData>(Literals{*this}), any);
   }
   // This is an externalized internal reference; just unwrap it.
-  assert(gcData->values.size() == 1);
-  return gcData->values[0];
+  assert(gcData->getLiterals().size() == 1);
+  return gcData->getLiterals()[0];
 }
 
 Literal Literal::unwrap() const {
@@ -3148,7 +3154,7 @@ Literal Literal::getJSPrototype() const {
   assert(type.isRef());
   if (auto desc = type.getHeapType().getDescriptorType();
       desc && JSUtils::hasPossibleJSPrototypeField(*desc)) {
-    auto proto = gcData->desc.getGCData()->values[0].unwrap();
+    auto proto = gcData->desc.getGCData()->getLiterals()[0].unwrap();
     // Strings and numbers are not valid prototypes, so they appear as null.
     // Externref nulls are also converted to nullref.
     auto protoType = proto.type.getHeapType();
@@ -3161,4 +3167,79 @@ Literal Literal::getJSPrototype() const {
   return Literal::makeNull(HeapType::none);
 }
 
+size_t Literal::getNumElements() const {
+  assert(isData());
+  if (gcData->isRawBytes()) {
+    auto field = type.getHeapType().getArray().element;
+    return gcData->getRawBytes().size() / field.getByteSize();
+  }
+  return gcData->getLiterals().size();
+}
+
+namespace {
+
+void writeField(void* dest, const Field& field, Literal value) {
+  if (field.isPacked()) {
+    assert(field.type == Type::i32);
+    int32_t c = value.geti32();
+    if (field.packedType == Field::i8) {
+      Bits::writeLE<int8_t>(static_cast<int8_t>(c), dest);
+    } else if (field.packedType == Field::i16) {
+      Bits::writeLE<int16_t>(static_cast<int16_t>(c), dest);
+    } else {
+      WASM_UNREACHABLE("invalid packed type");
+    }
+    return;
+  }
+
+  uint8_t buf[16];
+  assert(field.getByteSize() <= sizeof(buf));
+  value.getBits(buf);
+  memcpy(dest, buf, field.getByteSize());
+}
+
+Literal readField(const void* src, const Field& field, bool signed_) {
+  if (field.isPacked()) {
+    assert(field.type == Type::i32);
+    if (field.packedType == Field::i8) {
+      int8_t val = Bits::readLE<int8_t>(src);
+      return Literal(signed_ ? int32_t(val)
+                             : int32_t(static_cast<uint8_t>(val)));
+    } else if (field.packedType == Field::i16) {
+      int16_t val = Bits::readLE<int16_t>(src);
+      return Literal(signed_ ? int32_t(val)
+                             : int32_t(static_cast<uint16_t>(val)));
+    } else {
+      WASM_UNREACHABLE("invalid packed type");
+    }
+  }
+
+  return Literal::makeFromMemory(src, field.type);
+}
+
+} // anonymous namespace
+
+Literal Literal::getElement(size_t index, bool signed_) const {
+  assert(isData());
+  if (gcData->isRawBytes()) {
+    auto field = type.getHeapType().getArray().element;
+    size_t elemSize = field.getByteSize();
+    assert((index + 1) * elemSize <= gcData->getRawBytes().size());
+    return readField(&gcData->getRawBytes()[index * elemSize], field, signed_);
+  }
+  return gcData->getLiterals()[index];
+}
+
+void Literal::setElement(size_t index, Literal value) {
+  assert(isData());
+  if (gcData->isRawBytes()) {
+    auto field = type.getHeapType().getArray().element;
+    size_t elemSize = field.getByteSize();
+    assert((index + 1) * elemSize <= gcData->getRawBytes().size());
+    writeField(&gcData->getRawBytes()[index * elemSize], field, value);
+    return;
+  }
+  gcData->getLiterals()[index] = value;
+}
+
 } // namespace wasm
diff --git a/src/wasm/wasm-binary.cpp b/src/wasm/wasm-binary.cpp
index 43b528bebca..fa857fd8307 100644
--- a/src/wasm/wasm-binary.cpp
+++ b/src/wasm/wasm-binary.cpp
@@ -4182,6 +4182,9 @@ Result<> WasmBinaryReader::readInst() {
         case BinaryConsts::WaitqueueNew: {
           return builder.makeWaitqueueNew();
         }
+        case BinaryConsts::Publish: {
+          return builder.makePublish();
+        }
       }
       return Err{"unknown atomic operation " + std::to_string(op)};
     }
@@ -5330,8 +5333,15 @@ void WasmBinaryReader::readElementSegments() {
 
     if (isDeclarative) {
       // Declared segments are needed in wasm text and binary, but not in
-      // Binaryen IR; skip over the segment
-      [[maybe_unused]] auto type = getU32LEB();
+      // Binaryen IR; skip over the segment.
+      if (usesExpressions) {
+        [[maybe_unused]] auto type = getType();
+      } else {
+        auto elemKind = getU32LEB();
+        if (elemKind != 0x0) {
+          throwError("unexpected passive segment elemkind, expected 0, got " + std::to_string(elemKind));
+        }
+      }
       auto num = getU32LEB();
       for (Index i = 0; i < num; i++) {
         if (usesExpressions) {
@@ -5366,7 +5376,7 @@ void WasmBinaryReader::readElementSegments() {
       } else {
         auto elemKind = getU32LEB();
         if (elemKind != 0x0) {
-          throwError("Invalid kind (!= funcref(0)) since !usesExpressions.");
+          throwError("unexpected passive segment elemkind, expected 0, got " + std::to_string(elemKind));
         }
       }
     }
diff --git a/src/wasm/wasm-ir-builder.cpp b/src/wasm/wasm-ir-builder.cpp
index 92e397dd96e..bdc0da8fad2 100644
--- a/src/wasm/wasm-ir-builder.cpp
+++ b/src/wasm/wasm-ir-builder.cpp
@@ -21,7 +21,7 @@
 //
 // - Maintain a stack of control scopes (`ScopeCtx`).
 //
-// - Track an expression stack (`exprStack`) withing each scope.
+// - Track an expression stack (`exprStack`) within each scope.
 //
 // - Pop children from `exprStack` (via `ChildPopper`), set them as operands on
 //   the new Expression, and push the Expression back onto `exprStack`.
@@ -1160,7 +1160,7 @@ Result<> IRBuilder::visitEnd() {
       return curr;
     }
     auto* fixed = fixExtraOutput(scope, label, curr);
-    // We can re-use unnamed blocks instead of wrapping them.
+    // We can reuse unnamed blocks instead of wrapping them.
     if (auto* block = fixed->dynCast<Block>(); block && !block->name) {
       block->name = label;
       block->type = blockType;
@@ -2474,6 +2474,13 @@ Result<> IRBuilder::makeWaitqueueNotify() {
   return Ok{};
 }
 
+Result<> IRBuilder::makePublish() {
+  Publish curr(wasm.allocator);
+  CHECK_ERR(ChildPopper{*this}.visitPublish(&curr));
+  push(builder.makePublish(curr.ref));
+  return Ok{};
+}
+
 Result<> IRBuilder::makeArrayNew(HeapType type) {
   if (!type.isArray()) {
     return Err{"expected array type annotation on array.new"};
diff --git a/src/wasm/wasm-stack.cpp b/src/wasm/wasm-stack.cpp
index 5f1c6a13e8d..4f6c5d6d4e1 100644
--- a/src/wasm/wasm-stack.cpp
+++ b/src/wasm/wasm-stack.cpp
@@ -2755,6 +2755,11 @@ void BinaryInstWriter::visitWaitqueueNotify(WaitqueueNotify* curr) {
     << U32LEB(BinaryConsts::WaitqueueNotify);
 }
 
+void BinaryInstWriter::visitPublish(Publish* curr) {
+  o << static_cast<int8_t>(BinaryConsts::AtomicPrefix)
+    << U32LEB(BinaryConsts::Publish);
+}
+
 void BinaryInstWriter::visitArrayNew(ArrayNew* curr) {
   o << static_cast<int8_t>(BinaryConsts::GCPrefix);
   if (curr->isWithDefault()) {
diff --git a/src/wasm/wasm-type.cpp b/src/wasm/wasm-type.cpp
index ef8330724eb..51aa3e05e89 100644
--- a/src/wasm/wasm-type.cpp
+++ b/src/wasm/wasm-type.cpp
@@ -1487,6 +1487,8 @@ std::ostream& operator<<(std::ostream& os,
       return os << "Heap type describes an invalid unshared type";
     case TypeBuilder::ErrorReasonKind::RequiresCustomDescriptors:
       return os << "custom descriptors required but not enabled";
+    case TypeBuilder::ErrorReasonKind::MismatchedDescriptorFinality:
+      return os << "Descriptor and described types have mismatched finality";
     case TypeBuilder::ErrorReasonKind::RecGroupCollision:
       return os
              << "distinct rec groups would be identical after binary writing";
@@ -2284,6 +2286,11 @@ void TypeBuilder::setOpen(size_t i, bool open) {
   impl->entries[i].info->isOpen = open;
 }
 
+bool TypeBuilder::isOpen(size_t i) const {
+  assert(i < size() && "index out of bounds");
+  return impl->entries[i].info->isOpen;
+}
+
 void TypeBuilder::setShared(size_t i, Shareability share) {
   assert(i < size() && "index out of bounds");
   impl->entries[i].info->share = share;
@@ -2608,6 +2615,10 @@ buildRecGroup(std::unique_ptr<RecGroupInfo>&& groupInfo,
         return {TypeBuilder::Error{
           i, TypeBuilder::ErrorReasonKind::ForwardDescriptorReference}};
       }
+      if (type.isOpen() != desc->isOpen()) {
+        return {TypeBuilder::Error{
+          i, TypeBuilder::ErrorReasonKind::MismatchedDescriptorFinality}};
+      }
     }
     // Describes clauses were already checked as we validated each type in the
     // group.
diff --git a/src/wasm/wasm-validator.cpp b/src/wasm/wasm-validator.cpp
index 84e16745661..42da1dfb6c4 100644
--- a/src/wasm/wasm-validator.cpp
+++ b/src/wasm/wasm-validator.cpp
@@ -570,6 +570,7 @@ struct FunctionValidator : public WalkerPass<PostWalker<FunctionValidator>> {
   void visitStructWait(StructWait* curr);
   void visitWaitqueueNew(WaitqueueNew* curr);
   void visitWaitqueueNotify(WaitqueueNotify* curr);
+  void visitPublish(Publish* curr);
   void visitStringNew(StringNew* curr);
   void visitStringConst(StringConst* curr);
   void visitStringMeasure(StringMeasure* curr);
@@ -2627,7 +2628,7 @@ void FunctionValidator::visitRefAs(RefAs* curr) {
     case AnyConvertExtern: {
       shouldBeTrue(getModule()->features.hasGC(),
                    curr,
-                   "any.convert_extern requries GC [--enable-gc]");
+                   "any.convert_extern requires GC [--enable-gc]");
       if (curr->type == Type::unreachable) {
         return;
       }
@@ -2641,7 +2642,7 @@ void FunctionValidator::visitRefAs(RefAs* curr) {
     case ExternConvertAny: {
       shouldBeTrue(getModule()->features.hasGC(),
                    curr,
-                   "extern.convert_any requries GC [--enable-gc]");
+                   "extern.convert_any requires GC [--enable-gc]");
       if (curr->type == Type::unreachable) {
         return;
       }
@@ -3764,6 +3765,26 @@ void FunctionValidator::visitWaitqueueNotify(WaitqueueNotify* curr) {
                                     "waitqueue.notify count must be an i32");
 }
 
+void FunctionValidator::visitPublish(Publish* curr) {
+  shouldBeTrue(
+    !getModule() || getModule()->features.hasSharedEverything(),
+    curr,
+    "publish requires shared-everything [--enable-shared-everything]");
+
+  shouldBeTrue(curr->ref->type == Type::unreachable || curr->ref->type.isRef(),
+               curr->ref,
+               "publish's argument should be a reference type");
+
+  if (curr->ref->type == Type::unreachable) {
+    shouldBeEqual(curr->type,
+                  Type(Type::unreachable),
+                  curr,
+                  "unreachable publish value must have unreachable type");
+  } else {
+    shouldBeEqual(curr->ref->type, curr->type, curr, "bad publish type");
+  }
+}
+
 void FunctionValidator::visitArrayNew(ArrayNew* curr) {
   shouldBeTrue(
     getModule()->features.hasGC(), curr, "array.new requires gc [--enable-gc]");
@@ -5170,7 +5191,7 @@ void validateGlobals(Module& module, ValidationInfo& info) {
     }
     FunctionValidator(module, &info).validate(curr->init);
     // If GC is enabled (which means globals can refer to other non-imported
-    // globals), check that globals only refer to preceeding globals.
+    // globals), check that globals only refer to preceding globals.
     if (module.features.hasGC() && curr->init) {
       for (auto* get : FindAll<GlobalGet>(curr->init).list) {
         auto* global = module.getGlobalOrNull(get->name);
diff --git a/src/wasm/wasm.cpp b/src/wasm/wasm.cpp
index 37036b6e940..9be1b56cc5d 100644
--- a/src/wasm/wasm.cpp
+++ b/src/wasm/wasm.cpp
@@ -1357,6 +1357,8 @@ void WaitqueueNotify::finalize() {
   }
 }
 
+void Publish::finalize() { type = ref->type; }
+
 void ArrayNew::finalize() {
   if (size->type == Type::unreachable ||
       (init && init->type == Type::unreachable)) {
diff --git a/src/wasm2js.h b/src/wasm2js.h
index 9f912414ff1..83fdb20da1a 100644
--- a/src/wasm2js.h
+++ b/src/wasm2js.h
@@ -2356,6 +2356,10 @@ Ref Wasm2JSBuilder::processExpression(Expression* curr,
       unimplemented(curr);
       WASM_UNREACHABLE("unimp");
     }
+    Ref visitPublish(Publish* curr) {
+      unimplemented(curr);
+      WASM_UNREACHABLE("unimp");
+    }
     Ref visitArrayNew(ArrayNew* curr) {
       unimplemented(curr);
       WASM_UNREACHABLE("unimp");
diff --git a/test/binaryen.js/atomics.js b/test/binaryen.js/atomics.js
index 5eabd211e2e..52e430d9e22 100644
--- a/test/binaryen.js/atomics.js
+++ b/test/binaryen.js/atomics.js
@@ -7,7 +7,7 @@ var wast = `
 var module = binaryen.parseText(wast);
 
 // i32/i64.atomic.load/store
-module.addFunction("main", binaryen.none, binaryen.none, [], module.block("", [
+module.addFunction("main", binaryen.Type.none, binaryen.Type.none, [], module.block("", [
   // i32
   module.i32.atomic.store(0,
     module.i32.const(0),
diff --git a/test/binaryen.js/copy-expression.js b/test/binaryen.js/copy-expression.js
index 261c028faba..f6145d1fc94 100644
--- a/test/binaryen.js/copy-expression.js
+++ b/test/binaryen.js/copy-expression.js
@@ -3,11 +3,11 @@ var module = new binaryen.Module();
 // Create an expression and copy it
 var original = module.block(null, [
   module.if(
-    module.local.get(0, binaryen.i32),
+    module.local.get(0, binaryen.Type.i32),
     module.i32.const(1),
     module.i32.const(2)
   )
-], binaryen.i32);
+], binaryen.Type.i32);
 var copy = module.copyExpression(original);
 
 // Check that the expression incl. sub-expressions are copies
diff --git a/test/binaryen.js/emit_asmjs.js b/test/binaryen.js/emit_asmjs.js
index e7b9afee2a7..de4c4055305 100644
--- a/test/binaryen.js/emit_asmjs.js
+++ b/test/binaryen.js/emit_asmjs.js
@@ -1,6 +1,6 @@
 var module = new binaryen.Module();
 
-module.addFunction("main", binaryen.i32, binaryen.i32, [], module.local.get(0, binaryen.i32));
+module.addFunction("main", binaryen.Type.i32, binaryen.Type.i32, [], module.local.get(0, binaryen.Type.i32));
 
 module.addFunctionExport("main", "main");
 
diff --git a/test/binaryen.js/exception-handling.js b/test/binaryen.js/exception-handling.js
index 2a585137775..3656a9c1549 100644
--- a/test/binaryen.js/exception-handling.js
+++ b/test/binaryen.js/exception-handling.js
@@ -20,7 +20,7 @@ var module = new binaryen.Module();
 module.setFeatures(binaryen.Features.ReferenceTypes |
                    binaryen.Features.ExceptionHandling);
 
-module.addTag("e", binaryen.i32, binaryen.none);
+module.addTag("e", binaryen.Type.i32, binaryen.Type.none);
 
 // (try $l0
 //   (do
@@ -43,7 +43,7 @@ var try_catch = module.try(
         module.drop(module.i32.pop()),
         rethrow
       ],
-      binaryen.none
+      binaryen.Type.none
     )
   ],
   ''
@@ -83,13 +83,13 @@ var try_table = module.try_table(
   module.throw("e", [module.i32.const(0)]),
   [{ tag: null, dest: "catch_all_dest", ref: false }]
 );
-var try_table_block = module.block("catch_all_dest", [try_table], binaryen.none);
+var try_table_block = module.block("catch_all_dest", [try_table], binaryen.Type.none);
 
 // (throw_ref (ref.null noexn))
-var throw_ref = module.throw_ref(module.ref.null(binaryen.noexn));
+var throw_ref = module.throw_ref(module.ref.null(binaryen.HeapType.noexn));
 
 var body = module.block('', [try_catch, try_delegate, try_table_block, throw_ref])
-var func = module.addFunction("test", binaryen.none, binaryen.none, [], body);
+var func = module.addFunction("test", binaryen.Type.none, binaryen.Type.none, [], body);
 
 console.log(module.emitText());
 assert(module.validate());
diff --git a/test/binaryen.js/expressionrunner.js b/test/binaryen.js/expressionrunner.js
index 9535b3eeca7..1834c91ec4f 100644
--- a/test/binaryen.js/expressionrunner.js
+++ b/test/binaryen.js/expressionrunner.js
@@ -12,7 +12,7 @@ function assertDeepEqual(x, y) {
 }
 
 var module = new binaryen.Module();
-module.addGlobal("aGlobal", binaryen.i32, true, module.i32.const(0));
+module.addGlobal("aGlobal", binaryen.Type.i32, true, module.i32.const(0));
 
 // Should evaluate down to a constant
 var runner = new binaryen.ExpressionRunner(module);
@@ -26,7 +26,7 @@ assertDeepEqual(
   binaryen.getExpressionInfo(expr),
   {
     id: binaryen.ExpressionIds.Const,
-    type: binaryen.i32,
+    type: binaryen.Type.i32,
     value: 3
   }
 );
@@ -47,7 +47,7 @@ assertDeepEqual(
   binaryen.getExpressionInfo(expr),
   {
     id: binaryen.ExpressionIds.Const,
-    type: binaryen.i32,
+    type: binaryen.Type.i32,
     value: 4
   }
 );
@@ -56,7 +56,7 @@ assertDeepEqual(
 runner = new binaryen.ExpressionRunner(module);
 expr = runner.runAndDispose(
   module.i32.add(
-    module.local.get(0, binaryen.i32),
+    module.local.get(0, binaryen.Type.i32),
     module.i32.const(1)
   )
 );
@@ -73,7 +73,7 @@ assert(expr === 0);
 runner = new binaryen.ExpressionRunner(module);
 expr = runner.runAndDispose(
   module.i32.add(
-    module.local.tee(0, module.i32.const(4), binaryen.i32),
+    module.local.tee(0, module.i32.const(4), binaryen.Type.i32),
     module.i32.const(1)
   )
 );
@@ -81,7 +81,7 @@ assertDeepEqual(
   binaryen.getExpressionInfo(expr),
   {
     id: binaryen.ExpressionIds.Const,
-    type: binaryen.i32,
+    type: binaryen.Type.i32,
     value: 5
   }
 );
@@ -90,7 +90,7 @@ assertDeepEqual(
 runner = new binaryen.ExpressionRunner(module, Flags.PreserveSideeffects);
 expr = runner.runAndDispose(
   module.i32.add(
-    module.local.tee(0, module.i32.const(4), binaryen.i32),
+    module.local.tee(0, module.i32.const(4), binaryen.Type.i32),
     module.i32.const(1)
   )
 );
@@ -102,19 +102,19 @@ expr = runner.runAndDispose(
   module.i32.add(
     module.block(null, [
       module.local.set(0, module.i32.const(2)),
-      module.local.get(0, binaryen.i32)
-    ], binaryen.i32),
+      module.local.get(0, binaryen.Type.i32)
+    ], binaryen.Type.i32),
     module.block(null, [
       module.global.set("aGlobal", module.i32.const(4)),
-      module.global.get("aGlobal", binaryen.i32)
-    ], binaryen.i32)
+      module.global.get("aGlobal", binaryen.Type.i32)
+    ], binaryen.Type.i32)
   )
 );
 assertDeepEqual(
   binaryen.getExpressionInfo(expr),
   {
     id: binaryen.ExpressionIds.Const,
-    type: binaryen.i32,
+    type: binaryen.Type.i32,
     value: 6
   }
 );
@@ -125,15 +125,15 @@ assert(runner.setLocalValue(0, module.i32.const(3)));
 assert(runner.setGlobalValue("aGlobal", module.i32.const(4)));
 expr = runner.runAndDispose(
   module.i32.add(
-    module.local.get(0, binaryen.i32),
-    module.global.get("aGlobal", binaryen.i32)
+    module.local.get(0, binaryen.Type.i32),
+    module.global.get("aGlobal", binaryen.Type.i32)
   )
 );
 assertDeepEqual(
   binaryen.getExpressionInfo(expr),
   {
     id: binaryen.ExpressionIds.Const,
-    type: binaryen.i32,
+    type: binaryen.Type.i32,
     value: 7
   }
 );
@@ -146,7 +146,7 @@ expr = runner.runAndDispose(
     module.call("add", [
       module.i32.const(3),
       module.i32.const(4)
-    ], binaryen.i32)
+    ], binaryen.Type.i32)
   )
 );
 assert(expr === 0);
@@ -156,7 +156,7 @@ runner = new binaryen.ExpressionRunner(module, Flags.Default, 1);
 expr = runner.runAndDispose(
   module.block(null, [
     module.i32.const(1),
-  ], binaryen.i32)
+  ], binaryen.Type.i32)
 );
 assert(expr === 0);
 
diff --git a/test/binaryen.js/expressions.js b/test/binaryen.js/expressions.js
index 90290f284f3..c6241610c37 100644
--- a/test/binaryen.js/expressions.js
+++ b/test/binaryen.js/expressions.js
@@ -35,7 +35,7 @@ console.log("# Block");
   assert(theBlock instanceof binaryen.Expression);
   assert(theBlock.id === binaryen.BlockId);
   assert(theBlock.name === null);
-  assert(theBlock.type === binaryen.none);
+  assert(theBlock.type === binaryen.Type.none);
   
   var info = binaryen.getExpressionInfo(theBlock);
   assert(info.id === theBlock.id);
@@ -45,8 +45,8 @@ console.log("# Block");
 
   theBlock.name ="theName";
   assert(theBlock.name === "theName");
-  theBlock.type = binaryen.i32;
-  assert(theBlock.type === binaryen.i32);
+  theBlock.type = binaryen.Type.i32;
+  assert(theBlock.type === binaryen.Type.i32);
   assert(theBlock.numChildren === 0);
   assertDeepEqual(theBlock.children, []);
   assertDeepEqual(theBlock.getChildren(), []);
@@ -111,7 +111,7 @@ console.log("# If");
   assert(theIf.condition === condition);
   assert(theIf.ifTrue === ifTrue);
   assert(theIf.ifFalse === ifFalse);
-  assert(theIf.type == binaryen.i32);
+  assert(theIf.type == binaryen.Type.i32);
 
   var info = binaryen.getExpressionInfo(theIf);
   assert(info.id === theIf.id);
@@ -168,7 +168,7 @@ console.log("# Loop");
   assert(theLoop.id === binaryen.LoopId);
   assert(theLoop.name === name);
   assert(theLoop.body === body);
-  assert(theLoop.type === binaryen.i32);
+  assert(theLoop.type === binaryen.Type.i32);
 
   var info = binaryen.getExpressionInfo(theLoop);
   assert(info.id === theLoop.id);
@@ -181,7 +181,7 @@ console.log("# Loop");
   theLoop.body = body = module.drop(body);
   assert(theLoop.body === body);
   theLoop.finalize();
-  assert(theLoop.type === binaryen.none);
+  assert(theLoop.type === binaryen.Type.none);
 
   info = binaryen.getExpressionInfo(theLoop);
   assert(info.type === theLoop.type);
@@ -211,7 +211,7 @@ console.log("# Break");
   assert(theBreak.name === name);
   assert(theBreak.condition === condition);
   assert(theBreak.value === value);
-  assert(theBreak.type === binaryen.i32);
+  assert(theBreak.type === binaryen.Type.i32);
 
   var info = binaryen.getExpressionInfo(theBreak);
   assert(info.id === theBreak.id);
@@ -259,7 +259,7 @@ console.log("# Switch");
   assert(theSwitch.defaultName === defaultName);
   assert(theSwitch.condition === condition);
   assert(theSwitch.value === value);
-  assert(theSwitch.type === binaryen.unreachable);
+  assert(theSwitch.type === binaryen.Type.unreachable);
 
   var info = binaryen.getExpressionInfo(theSwitch);
   assert(info.id === theSwitch.id);
@@ -315,14 +315,14 @@ console.log("# Call");
     module.i32.const(1),
     module.i32.const(2)
   ];
-  const theCall = binaryen.Call(module.call(target, operands, binaryen.i32));
+  const theCall = binaryen.Call(module.call(target, operands, binaryen.Type.i32));
   assert(theCall instanceof binaryen.Call);
   assert(theCall instanceof binaryen.Expression);
   assert(theCall.target === target);
   assertDeepEqual(theCall.operands, operands);
   assertDeepEqual(theCall.getOperands(), operands);
   assert(theCall.return === false);
-  assert(theCall.type === binaryen.i32);
+  assert(theCall.type === binaryen.Type.i32);
 
   var info = binaryen.getExpressionInfo(theCall);
   assert(info.id === theCall.id);
@@ -350,7 +350,7 @@ console.log("# Call");
   theCall.return = true;
   assert(theCall.return === true);
   theCall.finalize();
-  assert(theCall.type === binaryen.unreachable); // finalized tail call
+  assert(theCall.type === binaryen.Type.unreachable); // finalized tail call
 
   info = binaryen.getExpressionInfo(theCall);
   assert(info.type === theCall.type);
@@ -359,9 +359,9 @@ console.log("# Call");
   assert(info.isReturn === theCall.return);
 
   theCall.return = false;
-  theCall.type = binaryen.i32;
+  theCall.type = binaryen.Type.i32;
   theCall.finalize();
-  assert(theCall.type === binaryen.i32); // finalized call
+  assert(theCall.type === binaryen.Type.i32); // finalized call
 
   info = binaryen.getExpressionInfo(theCall);
   assert(info.type === theCall.type);
@@ -383,8 +383,8 @@ console.log("# CallIndirect");
 
   var table = "0";
   var target = module.i32.const(42);
-  var params = binaryen.none;
-  var results = binaryen.none;
+  var params = binaryen.Type.none;
+  var results = binaryen.Type.none;
   var operands = [
     module.i32.const(1),
     module.i32.const(2)
@@ -429,12 +429,12 @@ console.log("# CallIndirect");
   theCallIndirect.insertOperandAt(0, module.i32.const(7));
   theCallIndirect.return = true;
   assert(theCallIndirect.return === true);
-  theCallIndirect.params = params = binaryen.createType([ binaryen.i32, binaryen.i32 ]);
+  theCallIndirect.params = params = binaryen.createType([ binaryen.Type.i32, binaryen.Type.i32 ]);
   assert(theCallIndirect.params === params);
-  theCallIndirect.results = results = binaryen.i32;
+  theCallIndirect.results = results = binaryen.Type.i32;
   assert(theCallIndirect.results === results);
   theCallIndirect.finalize();
-  assert(theCallIndirect.type === binaryen.unreachable); // finalized tail call
+  assert(theCallIndirect.type === binaryen.Type.unreachable); // finalized tail call
 
   info = binaryen.getExpressionInfo(theCallIndirect);
   assert(info.type === theCallIndirect.type);
@@ -466,7 +466,7 @@ console.log("# LocalGet");
   const module = new binaryen.Module();
 
   var index = 1;
-  var type = binaryen.i32;
+  var type = binaryen.Type.i32;
   const theLocalGet = binaryen.LocalGet(module.local.get(index, type));
   assert(theLocalGet instanceof binaryen.LocalGet);
   assert(theLocalGet instanceof binaryen.Expression);
@@ -480,7 +480,7 @@ console.log("# LocalGet");
 
   theLocalGet.index = index = 2;
   assert(theLocalGet.index === index);
-  theLocalGet.type = type = binaryen.f64;
+  theLocalGet.type = type = binaryen.Type.f64;
   assert(theLocalGet.type === type);
   theLocalGet.finalize();
 
@@ -510,7 +510,7 @@ console.log("# LocalSet");
   assert(theLocalSet.index === index);
   assert(theLocalSet.value === value);
   assert(theLocalSet.tee === false);
-  assert(theLocalSet.type == binaryen.none);
+  assert(theLocalSet.type == binaryen.Type.none);
 
   var info = binaryen.getExpressionInfo(theLocalSet);
   assert(info.id === theLocalSet.id);
@@ -523,10 +523,10 @@ console.log("# LocalSet");
   assert(theLocalSet.index === index);
   theLocalSet.value = value = module.i32.const(3);
   assert(theLocalSet.value === value);
-  theLocalSet.type = binaryen.i32;
-  assert(theLocalSet.type === binaryen.i32);
+  theLocalSet.type = binaryen.Type.i32;
+  assert(theLocalSet.type === binaryen.Type.i32);
   assert(theLocalSet.tee === true);
-  theLocalSet.type = binaryen.none;
+  theLocalSet.type = binaryen.Type.none;
   theLocalSet.finalize();
 
   info = binaryen.getExpressionInfo(theLocalSet);
@@ -550,7 +550,7 @@ console.log("# GlobalGet");
   const module = new binaryen.Module();
 
   var name = "a";
-  var type = binaryen.i32;
+  var type = binaryen.Type.i32;
   const theGlobalGet = binaryen.GlobalGet(module.global.get(name, type));
   assert(theGlobalGet instanceof binaryen.GlobalGet);
   assert(theGlobalGet instanceof binaryen.Expression);
@@ -564,7 +564,7 @@ console.log("# GlobalGet");
 
   theGlobalGet.name = name = "b";
   assert(theGlobalGet.name === name);
-  theGlobalGet.type = type = binaryen.f64;
+  theGlobalGet.type = type = binaryen.Type.f64;
   assert(theGlobalGet.type === type);
   theGlobalGet.finalize();
 
@@ -593,7 +593,7 @@ console.log("# GlobalSet");
   assert(theGlobalSet instanceof binaryen.Expression);
   assert(theGlobalSet.name === name);
   assert(theGlobalSet.value === value);
-  assert(theGlobalSet.type == binaryen.none);
+  assert(theGlobalSet.type == binaryen.Type.none);
 
   var info = binaryen.getExpressionInfo(theGlobalSet);
   assert(info.id === theGlobalSet.id);
@@ -625,7 +625,7 @@ console.log("# MemorySize");
 (function testMemorySize() {
   const module = new binaryen.Module();
   module.setMemory(1, 1, null);
-  var type = binaryen.i32;
+  var type = binaryen.Type.i32;
   const theMemorySize = binaryen.MemorySize(module.memory.size());
   assert(theMemorySize instanceof binaryen.MemorySize);
   assert(theMemorySize instanceof binaryen.Expression);
@@ -651,7 +651,7 @@ console.log("# MemoryGrow");
   const module = new binaryen.Module();
   module.setMemory(1, 1, null);
 
-  var type = binaryen.i32;
+  var type = binaryen.Type.i32;
   var delta = module.i32.const(1);
   const theMemoryGrow = binaryen.MemoryGrow(module.memory.grow(delta));
   assert(theMemoryGrow instanceof binaryen.MemoryGrow);
@@ -698,7 +698,7 @@ console.log("# Load");
   assert(theLoad.bytes === 4);
   assert(theLoad.signed === true);
   assert(theLoad.atomic === false);
-  assert(theLoad.type == binaryen.i32);
+  assert(theLoad.type == binaryen.Type.i32);
 
   var info = binaryen.getExpressionInfo(theLoad);
   assert(info.id === theLoad.id);
@@ -716,8 +716,8 @@ console.log("# Load");
   assert(theLoad.align === align);
   theLoad.ptr = ptr = module.i32.const(128);
   assert(theLoad.ptr === ptr);
-  theLoad.type = binaryen.i64;
-  assert(theLoad.type === binaryen.i64);
+  theLoad.type = binaryen.Type.i64;
+  assert(theLoad.type === binaryen.Type.i64);
   theLoad.signed = false;
   assert(theLoad.signed === false);
   theLoad.bytes = 8;
@@ -763,8 +763,8 @@ console.log("# Store");
   assert(theStore.value === value);
   assert(theStore.bytes === 4);
   assert(theStore.atomic === false);
-  assert(theStore.valueType === binaryen.i32);
-  assert(theStore.type === binaryen.none);
+  assert(theStore.valueType === binaryen.Type.i32);
+  assert(theStore.type === binaryen.Type.none);
 
   var info = binaryen.getExpressionInfo(theStore);
   assert(info.id === theStore.id);
@@ -787,8 +787,8 @@ console.log("# Store");
   assert(theStore.value === value);
   theStore.signed = false;
   assert(theStore.signed === false);
-  theStore.valueType = binaryen.i64;
-  assert(theStore.valueType === binaryen.i64);
+  theStore.valueType = binaryen.Type.i64;
+  assert(theStore.valueType === binaryen.Type.i64);
   theStore.bytes = 8;
   assert(theStore.bytes === 8);
   theStore.memoryOrder = binaryen.MemoryOrder.seqcst;
@@ -825,7 +825,7 @@ console.log("# Const");
   assert(theConst.valueI32 === 1);
   theConst.valueI32 = 2;
   assert(theConst.valueI32 === 2);
-  assert(theConst.type === binaryen.i32);
+  assert(theConst.type === binaryen.Type.i32);
 
   var info = binaryen.getExpressionInfo(theConst);
   assert(info.id === theConst.id);
@@ -835,7 +835,7 @@ console.log("# Const");
   theConst.valueI64 = 3;
   assert(theConst.valueI64 === 3n);
   theConst.finalize();
-  assert(theConst.type == binaryen.i64);
+  assert(theConst.type == binaryen.Type.i64);
 
   info = binaryen.getExpressionInfo(theConst);
   assert(info.type === theConst.type);
@@ -844,7 +844,7 @@ console.log("# Const");
   theConst.valueF32 = 5;
   assert(theConst.valueF32 === 5);
   theConst.finalize();
-  assert(theConst.type === binaryen.f32);
+  assert(theConst.type === binaryen.Type.f32);
 
   info = binaryen.getExpressionInfo(theConst);
   assert(info.type === theConst.type);
@@ -853,7 +853,7 @@ console.log("# Const");
   theConst.valueF64 = 6;
   assert(theConst.valueF64 === 6);
   theConst.finalize();
-  assert(theConst.type === binaryen.f64);
+  assert(theConst.type === binaryen.Type.f64);
 
   info = binaryen.getExpressionInfo(theConst);
   assert(info.type === theConst.type);
@@ -862,7 +862,7 @@ console.log("# Const");
   theConst.valueV128 = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16];
   assertDeepEqual(theConst.valueV128, [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16]);
   theConst.finalize();
-  assert(theConst.type === binaryen.v128);
+  assert(theConst.type === binaryen.Type.v128);
 
   info = binaryen.getExpressionInfo(theConst);
   assert(info.type === theConst.type);
@@ -889,7 +889,7 @@ console.log("# Unary");
   assert(theUnary instanceof binaryen.Expression);
   assert(theUnary.op === op);
   assert(theUnary.value === value);
-  assert(theUnary.type === binaryen.i32);
+  assert(theUnary.type === binaryen.Type.i32);
 
   var info = binaryen.getExpressionInfo(theUnary);
   assert(info.id === theUnary.id);
@@ -901,9 +901,9 @@ console.log("# Unary");
   assert(theUnary.op === op);
   theUnary.value = value = module.i64.const(2);
   assert(theUnary.value === value);
-  theUnary.type = binaryen.f32;
+  theUnary.type = binaryen.Type.f32;
   theUnary.finalize();
-  assert(theUnary.type === binaryen.i32);
+  assert(theUnary.type === binaryen.Type.i32);
 
   info = binaryen.getExpressionInfo(theUnary);
   assert(info.type === theUnary.type);
@@ -933,7 +933,7 @@ console.log("# Binary");
   assert(theBinary.op === op);
   assert(theBinary.left === left);
   assert(theBinary.right === right);
-  assert(theBinary.type === binaryen.i32)
+  assert(theBinary.type === binaryen.Type.i32)
 
   var info = binaryen.getExpressionInfo(theBinary);
   assert(info.id === theBinary.id);
@@ -948,9 +948,9 @@ console.log("# Binary");
   assert(theBinary.left === left);
   theBinary.right = right = module.i64.const(4);
   assert(theBinary.right === right);
-  theBinary.type = binaryen.f32;
+  theBinary.type = binaryen.Type.f32;
   theBinary.finalize();
-  assert(theBinary.type === binaryen.i64);
+  assert(theBinary.type === binaryen.Type.i64);
 
   info = binaryen.getExpressionInfo(theBinary);
   assert(info.type === theBinary.type);
@@ -1045,7 +1045,7 @@ console.log("# Select");
   assert(theSelect.condition === condition);
   assert(theSelect.ifTrue === ifTrue);
   assert(theSelect.ifFalse === ifFalse);
-  assert(theSelect.type === binaryen.i32);
+  assert(theSelect.type === binaryen.Type.i32);
 
   var info = binaryen.getExpressionInfo(theSelect);
   assert(info.id === theSelect.id);
@@ -1061,7 +1061,7 @@ console.log("# Select");
   theSelect.ifFalse = ifFalse = module.i64.const(6);
   assert(theSelect.ifFalse === ifFalse);
   theSelect.finalize();
-  assert(theSelect.type === binaryen.i64);
+  assert(theSelect.type === binaryen.Type.i64);
 
   info = binaryen.getExpressionInfo(theSelect);
   assert(info.type === theSelect.type);
@@ -1088,7 +1088,7 @@ console.log("# Drop");
   assert(theDrop instanceof binaryen.Drop);
   assert(theDrop instanceof binaryen.Expression);
   assert(theDrop.value === value);
-  assert(theDrop.type === binaryen.none);
+  assert(theDrop.type === binaryen.Type.none);
 
   var info = binaryen.getExpressionInfo(theDrop);
   assert(info.id === theDrop.id);
@@ -1099,7 +1099,7 @@ console.log("# Drop");
   assert(theDrop.value === value);
 
   theDrop.finalize();
-  assert(theDrop.type === binaryen.none);
+  assert(theDrop.type === binaryen.Type.none);
 
   info = binaryen.getExpressionInfo(theDrop);
   assert(info.type === theDrop.type);
@@ -1124,7 +1124,7 @@ console.log("# Return");
   assert(theReturn instanceof binaryen.Return);
   assert(theReturn instanceof binaryen.Expression);
   assert(theReturn.value === value);
-  assert(theReturn.type === binaryen.unreachable);
+  assert(theReturn.type === binaryen.Type.unreachable);
 
   var info = binaryen.getExpressionInfo(theReturn);
   assert(info.id === theReturn.id);
@@ -1135,7 +1135,7 @@ console.log("# Return");
   assert(theReturn.value === value);
 
   theReturn.finalize();
-  assert(theReturn.type === binaryen.unreachable);
+  assert(theReturn.type === binaryen.Type.unreachable);
 
   info = binaryen.getExpressionInfo(theReturn);
   assert(info.type === theReturn.type);
@@ -1168,7 +1168,7 @@ console.log("# AtomicRMW");
   assert(theAtomicRMW.offset === offset);
   assert(theAtomicRMW.ptr === ptr);
   assert(theAtomicRMW.value === value);
-  assert(theAtomicRMW.type === binaryen.i32);
+  assert(theAtomicRMW.type === binaryen.Type.i32);
 
   var info = binaryen.getExpressionInfo(theAtomicRMW);
   assert(info.id === theAtomicRMW.id);
@@ -1189,9 +1189,9 @@ console.log("# AtomicRMW");
   assert(theAtomicRMW.ptr === ptr);
   theAtomicRMW.value = value = module.i64.const(5);
   assert(theAtomicRMW.value === value);
-  theAtomicRMW.type = binaryen.i64;
+  theAtomicRMW.type = binaryen.Type.i64;
   theAtomicRMW.finalize();
-  assert(theAtomicRMW.type === binaryen.i64);
+  assert(theAtomicRMW.type === binaryen.Type.i64);
 
   info = binaryen.getExpressionInfo(theAtomicRMW);
   assert(info.type === theAtomicRMW.type);
@@ -1228,7 +1228,7 @@ console.log("# AtomicCmpxchg");
   assert(theAtomicCmpxchg.ptr === ptr);
   assert(theAtomicCmpxchg.expected === expected);
   assert(theAtomicCmpxchg.replacement === replacement);
-  assert(theAtomicCmpxchg.type === binaryen.i32);
+  assert(theAtomicCmpxchg.type === binaryen.Type.i32);
 
   var info = binaryen.getExpressionInfo(theAtomicCmpxchg);
   assert(info.id === theAtomicCmpxchg.id);
@@ -1249,9 +1249,9 @@ console.log("# AtomicCmpxchg");
   assert(theAtomicCmpxchg.expected === expected);
   theAtomicCmpxchg.replacement = replacement = module.i64.const(7);
   assert(theAtomicCmpxchg.replacement === replacement);
-  theAtomicCmpxchg.type = binaryen.i64;
+  theAtomicCmpxchg.type = binaryen.Type.i64;
   theAtomicCmpxchg.finalize();
-  assert(theAtomicCmpxchg.type === binaryen.i64);
+  assert(theAtomicCmpxchg.type === binaryen.Type.i64);
 
   info = binaryen.getExpressionInfo(theAtomicCmpxchg);
   assert(info.type === theAtomicCmpxchg.type);
@@ -1284,9 +1284,9 @@ console.log("# AtomicWait");
   assert(theAtomicWait instanceof binaryen.Expression);
   assert(theAtomicWait.ptr === ptr);
   assert(theAtomicWait.expected === expected);
-  assert(theAtomicWait.expectedType === binaryen.i32);
+  assert(theAtomicWait.expectedType === binaryen.Type.i32);
   assert(theAtomicWait.timeout === timeout);
-  assert(theAtomicWait.type === binaryen.i32);
+  assert(theAtomicWait.type === binaryen.Type.i32);
 
   var info = binaryen.getExpressionInfo(theAtomicWait);
   assert(info.id === theAtomicWait.id);
@@ -1300,13 +1300,13 @@ console.log("# AtomicWait");
   assert(theAtomicWait.ptr === ptr);
   theAtomicWait.expected = expected = module.i32.const(6);
   assert(theAtomicWait.expected === expected);
-  theAtomicWait.expectedType = binaryen.i64;
-  assert(theAtomicWait.expectedType === binaryen.i64);
+  theAtomicWait.expectedType = binaryen.Type.i64;
+  assert(theAtomicWait.expectedType === binaryen.Type.i64);
   theAtomicWait.timeout = timeout = module.i64.const(7);
   assert(theAtomicWait.timeout === timeout);
-  theAtomicWait.type = binaryen.f64;
+  theAtomicWait.type = binaryen.Type.f64;
   theAtomicWait.finalize();
-  assert(theAtomicWait.type === binaryen.i32);
+  assert(theAtomicWait.type === binaryen.Type.i32);
 
   info = binaryen.getExpressionInfo(theAtomicWait);
   assert(info.type === theAtomicWait.type);
@@ -1337,7 +1337,7 @@ console.log("# AtomicNotify");
   assert(theAtomicNotify instanceof binaryen.Expression);
   assert(theAtomicNotify.ptr === ptr);
   assert(theAtomicNotify.notifyCount === notifyCount);
-  assert(theAtomicNotify.type === binaryen.i32);
+  assert(theAtomicNotify.type === binaryen.Type.i32);
 
   var info = binaryen.getExpressionInfo(theAtomicNotify);
   assert(info.id === theAtomicNotify.id);
@@ -1349,9 +1349,9 @@ console.log("# AtomicNotify");
   assert(theAtomicNotify.ptr === ptr);
   theAtomicNotify.notifyCount = notifyCount = module.i32.const(4);
   assert(theAtomicNotify.notifyCount === notifyCount);
-  theAtomicNotify.type = binaryen.f64;
+  theAtomicNotify.type = binaryen.Type.f64;
   theAtomicNotify.finalize();
-  assert(theAtomicNotify.type === binaryen.i32);
+  assert(theAtomicNotify.type === binaryen.Type.i32);
 
   info = binaryen.getExpressionInfo(theAtomicNotify);
   assert(info.type === theAtomicNotify.type);
@@ -1376,7 +1376,7 @@ console.log("# AtomicFence");
   assert(theAtomicFence instanceof binaryen.AtomicFence);
   assert(theAtomicFence instanceof binaryen.Expression);
   assert(theAtomicFence.order === binaryen.MemoryOrder.seqcst);
-  assert(theAtomicFence.type === binaryen.none);
+  assert(theAtomicFence.type === binaryen.Type.none);
 
   var info = binaryen.getExpressionInfo(theAtomicFence);
   assert(info.id === theAtomicFence.id);
@@ -1413,7 +1413,7 @@ console.log("# SIMDExtract");
   assert(theSIMDExtract.op === op);
   assert(theSIMDExtract.vec === vec);
   assert(theSIMDExtract.index === index);
-  assert(theSIMDExtract.type === binaryen.i32);
+  assert(theSIMDExtract.type === binaryen.Type.i32);
 
   var info = binaryen.getExpressionInfo(theSIMDExtract);
   assert(info.id === theSIMDExtract.id);
@@ -1428,9 +1428,9 @@ console.log("# SIMDExtract");
   assert(theSIMDExtract.vec === vec);
   theSIMDExtract.index = index = 1;
   assert(theSIMDExtract.index === index);
-  theSIMDExtract.type = binaryen.f64;
+  theSIMDExtract.type = binaryen.Type.f64;
   theSIMDExtract.finalize();
-  assert(theSIMDExtract.type === binaryen.i32);
+  assert(theSIMDExtract.type === binaryen.Type.i32);
   
   info = binaryen.getExpressionInfo(theSIMDExtract);
   assert(info.type === theSIMDExtract.type);
@@ -1463,7 +1463,7 @@ console.log("# SIMDReplace");
   assert(theSIMDReplace.vec === vec);
   assert(theSIMDReplace.index === index);
   assert(theSIMDReplace.value === value);
-  assert(theSIMDReplace.type === binaryen.v128);
+  assert(theSIMDReplace.type === binaryen.Type.v128);
 
   var info = binaryen.getExpressionInfo(theSIMDReplace);
   assert(info.id === theSIMDReplace.id);
@@ -1481,9 +1481,9 @@ console.log("# SIMDReplace");
   assert(theSIMDReplace.index === index);
   theSIMDReplace.value = value = module.i32.const(2);
   assert(theSIMDReplace.value === value);
-  theSIMDReplace.type = binaryen.f64;
+  theSIMDReplace.type = binaryen.Type.f64;
   theSIMDReplace.finalize();
-  assert(theSIMDReplace.type === binaryen.v128);
+  assert(theSIMDReplace.type === binaryen.Type.v128);
 
   info = binaryen.getExpressionInfo(theSIMDReplace);
   assert(info.type === theSIMDReplace.type);
@@ -1515,7 +1515,7 @@ console.log("# SIMDShuffle");
   assert(theSIMDShuffle.left === left);
   assert(theSIMDShuffle.right === right);
   assertDeepEqual(theSIMDShuffle.mask, mask);
-  assert(theSIMDShuffle.type === binaryen.v128);
+  assert(theSIMDShuffle.type === binaryen.Type.v128);
 
   var info = binaryen.getExpressionInfo(theSIMDShuffle);
   assert(info.id === theSIMDShuffle.id);
@@ -1530,9 +1530,9 @@ console.log("# SIMDShuffle");
   assert(theSIMDShuffle.right === right);
   theSIMDShuffle.mask = mask = [3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3];
   assertDeepEqual(theSIMDShuffle.mask, mask);
-  theSIMDShuffle.type = binaryen.f64;
+  theSIMDShuffle.type = binaryen.Type.f64;
   theSIMDShuffle.finalize();
-  assert(theSIMDShuffle.type === binaryen.v128);
+  assert(theSIMDShuffle.type === binaryen.Type.v128);
 
   info = binaryen.getExpressionInfo(theSIMDShuffle);
   assert(info.type === theSIMDShuffle.type);
@@ -1565,7 +1565,7 @@ console.log("# SIMDTernary");
   assert(theSIMDTernary.a === a);
   assert(theSIMDTernary.b === b);
   assert(theSIMDTernary.c === c);
-  assert(theSIMDTernary.type === binaryen.v128);
+  assert(theSIMDTernary.type === binaryen.Type.v128);
 
   var info = binaryen.getExpressionInfo(theSIMDTernary);
   assert(info.id === theSIMDTernary.id);
@@ -1598,7 +1598,7 @@ console.log("# SIMDShift");
   assert(theSIMDShift.op === op);
   assert(theSIMDShift.vec === vec);
   assert(theSIMDShift.shift === shift);
-  assert(theSIMDShift.type === binaryen.v128);
+  assert(theSIMDShift.type === binaryen.Type.v128);
 
   var info = binaryen.getExpressionInfo(theSIMDShift);
   assert(info.id === theSIMDShift.id);
@@ -1613,9 +1613,9 @@ console.log("# SIMDShift");
   assert(theSIMDShift.vec === vec);
   theSIMDShift.shift = shift = module.i32.const(2);
   assert(theSIMDShift.shift === shift);
-  theSIMDShift.type = binaryen.f64;
+  theSIMDShift.type = binaryen.Type.f64;
   theSIMDShift.finalize();
-  assert(theSIMDShift.type === binaryen.v128);
+  assert(theSIMDShift.type === binaryen.Type.v128);
 
   info = binaryen.getExpressionInfo(theSIMDShift);
   assert(info.type === theSIMDShift.type);
@@ -1648,7 +1648,7 @@ console.log("# SIMDLoad");
   assert(theSIMDLoad.offset === offset);
   assert(theSIMDLoad.align === align);
   assert(theSIMDLoad.ptr === ptr);
-  assert(theSIMDLoad.type === binaryen.v128);
+  assert(theSIMDLoad.type === binaryen.Type.v128);
 
   var info = binaryen.getExpressionInfo(theSIMDLoad);
   assert(info.id === theSIMDLoad.id);
@@ -1665,9 +1665,9 @@ console.log("# SIMDLoad");
   assert(theSIMDLoad.align === align);
   theSIMDLoad.ptr = ptr = module.i32.const(2);
   assert(theSIMDLoad.ptr === ptr);
-  theSIMDLoad.type = binaryen.f64;
+  theSIMDLoad.type = binaryen.Type.f64;
   theSIMDLoad.finalize();
-  assert(theSIMDLoad.type === binaryen.v128);
+  assert(theSIMDLoad.type === binaryen.Type.v128);
 
   info = binaryen.getExpressionInfo(theSIMDLoad);
   assert(info.type === theSIMDLoad.type);
@@ -1705,7 +1705,7 @@ console.log("# SIMDLoadStoreLane");
   assert(theSIMDLoadStoreLane.index === index);
   assert(theSIMDLoadStoreLane.ptr === ptr);
   assert(theSIMDLoadStoreLane.vec === vec);
-  assert(theSIMDLoadStoreLane.type === binaryen.v128);
+  assert(theSIMDLoadStoreLane.type === binaryen.Type.v128);
   assert(theSIMDLoadStoreLane.store === false);
 
   var info = binaryen.getExpressionInfo(theSIMDLoadStoreLane);
@@ -1731,9 +1731,9 @@ console.log("# SIMDLoadStoreLane");
   assert(theSIMDLoadStoreLane.ptr === ptr);
   theSIMDLoadStoreLane.vec = vec = module.v128.const([1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]);
   assert(theSIMDLoadStoreLane.vec === vec);
-  theSIMDLoadStoreLane.type = binaryen.f64;
+  theSIMDLoadStoreLane.type = binaryen.Type.f64;
   theSIMDLoadStoreLane.finalize();
-  assert(theSIMDLoadStoreLane.type === binaryen.v128);
+  assert(theSIMDLoadStoreLane.type === binaryen.Type.v128);
 
   info = binaryen.getExpressionInfo(theSIMDLoadStoreLane);
   assert(info.type === theSIMDLoadStoreLane.type);
@@ -1753,10 +1753,10 @@ console.log("# SIMDLoadStoreLane");
 
   theSIMDLoadStoreLane.op = op = binaryen.Operations.Store16LaneVec128;
   assert(theSIMDLoadStoreLane.op === op);
-  theSIMDLoadStoreLane.type = binaryen.f64;
+  theSIMDLoadStoreLane.type = binaryen.Type.f64;
   assert(theSIMDLoadStoreLane.store === true);
   theSIMDLoadStoreLane.finalize();
-  assert(theSIMDLoadStoreLane.type === binaryen.none);
+  assert(theSIMDLoadStoreLane.type === binaryen.Type.none);
 
   info = binaryen.getExpressionInfo(theSIMDLoadStoreLane);
   assert(info.type === theSIMDLoadStoreLane.type);
@@ -1789,7 +1789,7 @@ console.log("# MemoryInit");
   assert(theMemoryInit.dest === dest);
   assert(theMemoryInit.offset === offset);
   assert(theMemoryInit.size === size);
-  assert(theMemoryInit.type === binaryen.none);
+  assert(theMemoryInit.type === binaryen.Type.none);
 
   var info = binaryen.getExpressionInfo(theMemoryInit);
   assert(info.id === theMemoryInit.id);
@@ -1807,9 +1807,9 @@ console.log("# MemoryInit");
   assert(theMemoryInit.offset === offset);
   theMemoryInit.size = size = module.i32.const(8);
   assert(theMemoryInit.size === size);
-  theMemoryInit.type = binaryen.f64;
+  theMemoryInit.type = binaryen.Type.f64;
   theMemoryInit.finalize();
-  assert(theMemoryInit.type === binaryen.none);
+  assert(theMemoryInit.type === binaryen.Type.none);
 
   info = binaryen.getExpressionInfo(theMemoryInit);
   assert(info.type === theMemoryInit.type);
@@ -1837,7 +1837,7 @@ console.log("# DataDrop");
   assert(theDataDrop instanceof binaryen.DataDrop);
   assert(theDataDrop instanceof binaryen.Expression);
   assert(theDataDrop.segment === segment);
-  assert(theDataDrop.type === binaryen.none);
+  assert(theDataDrop.type === binaryen.Type.none);
 
   var info = binaryen.getExpressionInfo(theDataDrop);
   assert(info.id === theDataDrop.id);
@@ -1846,9 +1846,9 @@ console.log("# DataDrop");
 
   theDataDrop.segment = segment = "2";
   assert(theDataDrop.segment === "2");
-  theDataDrop.type = binaryen.f64;
+  theDataDrop.type = binaryen.Type.f64;
   theDataDrop.finalize();
-  assert(theDataDrop.type === binaryen.none);
+  assert(theDataDrop.type === binaryen.Type.none);
 
   info = binaryen.getExpressionInfo(theDataDrop);
   assert(info.type === theDataDrop.type);
@@ -1878,7 +1878,7 @@ console.log("# MemoryCopy");
   assert(theMemoryCopy.dest === dest);
   assert(theMemoryCopy.source === source);
   assert(theMemoryCopy.size === size);
-  assert(theMemoryCopy.type === binaryen.none);
+  assert(theMemoryCopy.type === binaryen.Type.none);
 
   var info = binaryen.getExpressionInfo(theMemoryCopy);
   assert(info.id === theMemoryCopy.id);
@@ -1893,9 +1893,9 @@ console.log("# MemoryCopy");
   assert(theMemoryCopy.source === source);
   theMemoryCopy.size = size = module.i32.const(6);
   assert(theMemoryCopy.size === size);
-  theMemoryCopy.type = binaryen.f64;
+  theMemoryCopy.type = binaryen.Type.f64;
   theMemoryCopy.finalize();
-  assert(theMemoryCopy.type === binaryen.none);
+  assert(theMemoryCopy.type === binaryen.Type.none);
 
   info = binaryen.getExpressionInfo(theMemoryCopy);
   assert(info.type === theMemoryCopy.type);
@@ -1927,7 +1927,7 @@ console.log("# MemoryFill");
   assert(theMemoryFill.dest === dest);
   assert(theMemoryFill.value === value);
   assert(theMemoryFill.size === size);
-  assert(theMemoryFill.type === binaryen.none);
+  assert(theMemoryFill.type === binaryen.Type.none);
 
   var info = binaryen.getExpressionInfo(theMemoryFill);
   assert(info.id === theMemoryFill.id);
@@ -1942,9 +1942,9 @@ console.log("# MemoryFill");
   assert(theMemoryFill.value === value);
   theMemoryFill.size = size = module.i32.const(6);
   assert(theMemoryFill.size === size);
-  theMemoryFill.type = binaryen.f64;
+  theMemoryFill.type = binaryen.Type.f64;
   theMemoryFill.finalize();
-  assert(theMemoryFill.type === binaryen.none);
+  assert(theMemoryFill.type === binaryen.Type.none);
 
   info = binaryen.getExpressionInfo(theMemoryFill);
   assert(info.type === theMemoryFill.type);
@@ -1966,23 +1966,23 @@ console.log("# RefIsNull");
 (function testRefIsNull() {
   const module = new binaryen.Module();
 
-  var value = module.local.get(1, binaryen.externref);
+  var value = module.local.get(1, binaryen.Type.externref);
   const theRefIsNull = binaryen.RefIsNull(module.ref.is_null(value));
   assert(theRefIsNull instanceof binaryen.RefIsNull);
   assert(theRefIsNull instanceof binaryen.Expression);
   assert(theRefIsNull.value === value);
-  assert(theRefIsNull.type === binaryen.i32);
+  assert(theRefIsNull.type === binaryen.Type.i32);
 
   var info = binaryen.getExpressionInfo(theRefIsNull);
   assert(info.id === theRefIsNull.id);
   assert(info.type === theRefIsNull.type);
   assert(info.value === theRefIsNull.value);
 
-  theRefIsNull.value = value = module.local.get(2, binaryen.externref);
+  theRefIsNull.value = value = module.local.get(2, binaryen.Type.externref);
   assert(theRefIsNull.value === value);
-  theRefIsNull.type = binaryen.f64;
+  theRefIsNull.type = binaryen.Type.f64;
   theRefIsNull.finalize();
-  assert(theRefIsNull.type === binaryen.i32);
+  assert(theRefIsNull.type === binaryen.Type.i32);
 
   info = binaryen.getExpressionInfo(theRefIsNull);
   assert(info.type === theRefIsNull.type);
@@ -2003,14 +2003,14 @@ console.log("# RefAs");
   const module = new binaryen.Module();
 
   var op = binaryen.Operations.RefAsNonNull;
-  var value = module.local.get(1, binaryen.anyref);
-  var externref = module.local.get(3, binaryen.externref);
+  var value = module.local.get(1, binaryen.Type.anyref);
+  var externref = module.local.get(3, binaryen.Type.externref);
   const theRefAs = binaryen.RefAs(module.ref.as_non_null(value));
   assert(theRefAs instanceof binaryen.RefAs);
   assert(theRefAs instanceof binaryen.Expression);
   assert(theRefAs.op === op);
   assert(theRefAs.value === value);
-  assert(theRefAs.type !== binaryen.i32); // TODO: === (ref any)
+  assert(theRefAs.type !== binaryen.Type.i32); // TODO: === (ref any)
 
   var info = binaryen.getExpressionInfo(theRefAs);
   assert(info.id === theRefAs.id);
@@ -2021,11 +2021,11 @@ console.log("# RefAs");
   theRefAs.op = op = binaryen.Operations.RefAsExternConvertAny;
   assert(theRefAs.op === op);
   theRefAs.op = op = binaryen.Operations.RefAsNonNull;
-  theRefAs.value = value = module.local.get(2, binaryen.anyref);
+  theRefAs.value = value = module.local.get(2, binaryen.Type.anyref);
   assert(theRefAs.value === value);
-  theRefAs.type = binaryen.f64;
+  theRefAs.type = binaryen.Type.f64;
   theRefAs.finalize();
-  assert(theRefAs.type !== binaryen.f64); // TODO: === (ref any)
+  assert(theRefAs.type !== binaryen.Type.f64); // TODO: === (ref any)
 
   info = binaryen.getExpressionInfo(theRefAs);
   assert(info.type === theRefAs.type);
@@ -2047,7 +2047,7 @@ console.log("# RefAs");
 console.log("# RefFunc");
 (function testRefFunc() {
   const module = new binaryen.Module();
-  module.addFunction("a", binaryen.none, binaryen.none, [], module.nop());
+  module.addFunction("a", binaryen.Type.none, binaryen.Type.none, [], module.nop());
   var type = binaryen.Function(module.getFunction("a")).type;
 
   var func = "a";
@@ -2087,14 +2087,14 @@ console.log("# RefEq");
 (function testRefEq() {
   const module = new binaryen.Module();
 
-  var left = module.local.get(0, binaryen.eqref);
-  var right = module.local.get(1, binaryen.eqref);
+  var left = module.local.get(0, binaryen.Type.eqref);
+  var right = module.local.get(1, binaryen.Type.eqref);
   const theRefEq = binaryen.RefEq(module.ref.eq(left, right));
   assert(theRefEq instanceof binaryen.RefEq);
   assert(theRefEq instanceof binaryen.Expression);
   assert(theRefEq.left === left);
   assert(theRefEq.right === right);
-  assert(theRefEq.type === binaryen.i32);
+  assert(theRefEq.type === binaryen.Type.i32);
 
   var info = binaryen.getExpressionInfo(theRefEq);
   assert(info.id === theRefEq.id);
@@ -2102,13 +2102,13 @@ console.log("# RefEq");
   assert(info.left === theRefEq.left);
   assert(info.right === theRefEq.right);
 
-  theRefEq.left = left = module.local.get(2, binaryen.eqref);
+  theRefEq.left = left = module.local.get(2, binaryen.Type.eqref);
   assert(theRefEq.left === left);
-  theRefEq.right = right = module.local.get(3, binaryen.eqref);
+  theRefEq.right = right = module.local.get(3, binaryen.Type.eqref);
   assert(theRefEq.right === right);
-  theRefEq.type = binaryen.f64;
+  theRefEq.type = binaryen.Type.f64;
   theRefEq.finalize();
-  assert(theRefEq.type === binaryen.i32);
+  assert(theRefEq.type === binaryen.Type.i32);
 
   info = binaryen.getExpressionInfo(theRefEq);
   assert(info.type === theRefEq.type);
@@ -2129,14 +2129,14 @@ console.log("# RefTest");
 (function testRefTest() {
   const module = new binaryen.Module();
 
-  var ref = module.local.get(0, binaryen.anyref);
-  var castType = binaryen.anyref;
+  var ref = module.local.get(0, binaryen.Type.anyref);
+  var castType = binaryen.Type.anyref;
   const theRefTest = binaryen.RefTest(module.ref.test(ref, castType));
   assert(theRefTest instanceof binaryen.RefTest);
   assert(theRefTest instanceof binaryen.Expression);
   assert(theRefTest.ref === ref);
   assert(theRefTest.castType === castType);
-  assert(theRefTest.type === binaryen.i32);
+  assert(theRefTest.type === binaryen.Type.i32);
 
   var info = binaryen.getExpressionInfo(theRefTest);
   assert(info.id === theRefTest.id);
@@ -2144,13 +2144,13 @@ console.log("# RefTest");
   assert(info.ref === theRefTest.ref);
   assert(info.castType === theRefTest.castType);
 
-  theRefTest.ref = ref = module.local.get(2, binaryen.externref);
+  theRefTest.ref = ref = module.local.get(2, binaryen.Type.externref);
   assert(theRefTest.ref === ref);
-  theRefTest.castType = castType = binaryen.externref;
+  theRefTest.castType = castType = binaryen.Type.externref;
   assert(theRefTest.castType === castType);
-  theRefTest.type = binaryen.f64;
+  theRefTest.type = binaryen.Type.f64;
   theRefTest.finalize();
-  assert(theRefTest.type === binaryen.i32);
+  assert(theRefTest.type === binaryen.Type.i32);
 
   info = binaryen.getExpressionInfo(theRefTest);
   assert(info.type === theRefTest.type);
@@ -2171,8 +2171,8 @@ console.log("# RefCast");
 (function testRefCast() {
   const module = new binaryen.Module();
 
-  var ref = module.local.get(0, binaryen.anyref);
-  var type = binaryen.anyref;
+  var ref = module.local.get(0, binaryen.Type.anyref);
+  var type = binaryen.Type.anyref;
   const theRefCast = binaryen.RefCast(module.ref.cast(ref, type));
   assert(theRefCast instanceof binaryen.RefCast);
   assert(theRefCast instanceof binaryen.Expression);
@@ -2184,9 +2184,9 @@ console.log("# RefCast");
   assert(info.type === theRefCast.type);
   assert(info.ref === theRefCast.ref);
 
-  theRefCast.ref = ref = module.local.get(2, binaryen.externref);
+  theRefCast.ref = ref = module.local.get(2, binaryen.Type.externref);
   assert(theRefCast.ref === ref);
-  theRefCast.type = type = binaryen.externref;
+  theRefCast.type = type = binaryen.Type.externref;
   theRefCast.finalize();
   assert(theRefCast.type === type);
 
@@ -2209,9 +2209,9 @@ console.log("# BrOn");
   const module = new binaryen.Module();
 
   var name = "br";
-  var ref = module.local.get(0, binaryen.externref);
+  var ref = module.local.get(0, binaryen.Type.externref);
   var op = binaryen.Operations.BrOnNull;
-  var castType = binaryen.unreachable;
+  var castType = binaryen.Type.unreachable;
   const theBrOn = binaryen.BrOn(module.br_on_null(name, ref));
   assert(theBrOn instanceof binaryen.BrOn);
   assert(theBrOn instanceof binaryen.Expression);
@@ -2232,11 +2232,11 @@ console.log("# BrOn");
 
   theBrOn.name = name = "br2";
   assert(theBrOn.name === name);
-  theBrOn.ref = ref = module.local.get(1, binaryen.anyref);
+  theBrOn.ref = ref = module.local.get(1, binaryen.Type.anyref);
   assert(theBrOn.ref === ref);
   theBrOn.op = op = binaryen.Operations.BrOnCast;
   assert(theBrOn.op === op);
-  theBrOn.castType = castType = binaryen.i31ref;
+  theBrOn.castType = castType = binaryen.Type.i31ref;
   assert(theBrOn.castType === castType);
   theBrOn.finalize();
 
@@ -2260,11 +2260,11 @@ console.log("# StructNew");
 (function testStructNew() {
   const builder = new binaryen.TypeBuilder(2);
   builder.setStructType(0, [
-    { type: binaryen.i32, packedType: binaryen.notPacked, mutable: true },
+    { type: binaryen.Type.i32, packedType: binaryen.PackedType.notPacked, mutable: true },
   ]);
   builder.setStructType(1, [
-    { type: binaryen.i32, packedType: binaryen.i16, mutable: true },
-    { type: binaryen.i64, packedType: binaryen.notPacked, mutable: true }
+    { type: binaryen.Type.i32, packedType: binaryen.PackedType.i16, mutable: true },
+    { type: binaryen.Type.i64, packedType: binaryen.PackedType.notPacked, mutable: true }
   ]);
   var [
     struct0Type,
@@ -2327,11 +2327,11 @@ console.log("# StructGet");
 (function testStructGet() {
   const builder = new binaryen.TypeBuilder(2);
   builder.setStructType(0, [
-    { type: binaryen.i32, packedType: binaryen.notPacked, mutable: true },
+    { type: binaryen.Type.i32, packedType: binaryen.PackedType.notPacked, mutable: true },
   ]);
   builder.setStructType(1, [
-    { type: binaryen.i32, packedType: binaryen.i16, mutable: true },
-    { type: binaryen.i64, packedType: binaryen.notPacked, mutable: true }
+    { type: binaryen.Type.i32, packedType: binaryen.PackedType.i16, mutable: true },
+    { type: binaryen.Type.i64, packedType: binaryen.PackedType.notPacked, mutable: true }
   ]);
   var [
     struct0Type,
@@ -2342,7 +2342,7 @@ console.log("# StructGet");
 
   var index = 0;
   var ref = module.local.get(0, struct0Type);
-  var type = binaryen.i32;
+  var type = binaryen.Type.i32;
   var signed = false;
   const theStructGet = binaryen.StructGet(module.struct.get(index, ref, type, signed));
   assert(theStructGet instanceof binaryen.StructGet);
@@ -2365,7 +2365,7 @@ console.log("# StructGet");
   assert(theStructGet.ref === ref);
   theStructGet.signed = signed = true;
   assert(theStructGet.signed === signed);
-  theStructGet.type = type = binaryen.i64;
+  theStructGet.type = type = binaryen.Type.i64;
   theStructGet.finalize();
   assert(theStructGet.type === type);
 
@@ -2389,11 +2389,11 @@ console.log("# StructSet");
 (function testStructSet() {
   const builder = new binaryen.TypeBuilder(2);
   builder.setStructType(0, [
-    { type: binaryen.i32, packedType: binaryen.notPacked, mutable: true },
+    { type: binaryen.Type.i32, packedType: binaryen.PackedType.notPacked, mutable: true },
   ]);
   builder.setStructType(1, [
-    { type: binaryen.i32, packedType: binaryen.i16, mutable: true },
-    { type: binaryen.i64, packedType: binaryen.notPacked, mutable: true }
+    { type: binaryen.Type.i32, packedType: binaryen.PackedType.i16, mutable: true },
+    { type: binaryen.Type.i64, packedType: binaryen.PackedType.notPacked, mutable: true }
   ]);
   var [
     struct0Type,
@@ -2404,14 +2404,14 @@ console.log("# StructSet");
 
   var index = 0;
   var ref = module.local.get(0, struct0Type);
-  var value = module.local.get(1, binaryen.i32);
+  var value = module.local.get(1, binaryen.Type.i32);
   const theStructSet = binaryen.StructSet(module.struct.set(index, ref, value));
   assert(theStructSet instanceof binaryen.StructSet);
   assert(theStructSet instanceof binaryen.Expression);
   assert(theStructSet.index === index);
   assert(theStructSet.ref === ref);
   assert(theStructSet.value === value);
-  assert(theStructSet.type === binaryen.none);
+  assert(theStructSet.type === binaryen.Type.none);
 
   var info = binaryen.getExpressionInfo(theStructSet);
   assert(info.id === theStructSet.id);
@@ -2424,11 +2424,11 @@ console.log("# StructSet");
   assert(theStructSet.index === index);
   theStructSet.ref = ref = module.local.get(2, struct1Type);
   assert(theStructSet.ref === ref);
-  theStructSet.value = value = module.local.get(3, binaryen.i64);
+  theStructSet.value = value = module.local.get(3, binaryen.Type.i64);
   assert(theStructSet.value === value);
-  theStructSet.type = binaryen.f64;
+  theStructSet.type = binaryen.Type.f64;
   theStructSet.finalize();
-  assert(theStructSet.type === binaryen.none);
+  assert(theStructSet.type === binaryen.Type.none);
 
   info = binaryen.getExpressionInfo(theStructSet);
   assert(info.type === theStructSet.type);
@@ -2450,7 +2450,7 @@ console.log("# StructWait");
 (function testStructWait() {
   const builder = new binaryen.TypeBuilder(1);
   builder.setStructType(0, [
-    { type: binaryen.i32, packedType: binaryen.notPacked, mutable: true },
+    { type: binaryen.Type.i32, packedType: binaryen.PackedType.notPacked, mutable: true },
   ]);
   var [
     struct0Type
@@ -2460,9 +2460,9 @@ console.log("# StructWait");
 
   var ref = module.local.get(0, struct0Type);
   var index = 0;
-  var expected = module.local.get(1, binaryen.i32);
-  var timeout = module.local.get(2, binaryen.i64);
-  var waitqueue = module.local.get(3, binaryen.anyref);
+  var expected = module.local.get(1, binaryen.Type.i32);
+  var timeout = module.local.get(2, binaryen.Type.i64);
+  var waitqueue = module.local.get(3, binaryen.Type.anyref);
   const theStructWait = binaryen.StructWait(module.struct.wait(ref, index, expected, timeout, waitqueue));
   assert(theStructWait instanceof binaryen.StructWait);
   assert(theStructWait instanceof binaryen.Expression);
@@ -2471,7 +2471,7 @@ console.log("# StructWait");
   assert(theStructWait.expected === expected);
   assert(theStructWait.timeout === timeout);
   assert(theStructWait.waitqueue === waitqueue);
-  assert(theStructWait.type === binaryen.i32);
+  assert(theStructWait.type === binaryen.Type.i32);
 
   var info = binaryen.getExpressionInfo(theStructWait);
   assert(info.id === theStructWait.id);
@@ -2508,8 +2508,8 @@ console.log("# WaitqueueNotify");
 (function testWaitqueueNotify() {
   const module = new binaryen.Module();
 
-  var waitqueue = module.local.get(0, binaryen.anyref);
-  var count = module.local.get(1, binaryen.i32);
+  var waitqueue = module.local.get(0, binaryen.Type.anyref);
+  var count = module.local.get(1, binaryen.Type.i32);
   const theWaitqueueNotify = binaryen.WaitqueueNotify(module.waitqueue.notify(waitqueue, count));
   assert(theWaitqueueNotify instanceof binaryen.WaitqueueNotify);
   assert(theWaitqueueNotify instanceof binaryen.Expression);
@@ -2530,8 +2530,8 @@ console.log("# WaitqueueNotify");
 console.log("# ArrayNew");
 (function testArrayNew() {
   const builder = new binaryen.TypeBuilder(2);
-  builder.setArrayType(0, binaryen.i32, binaryen.i16, true);
-  builder.setArrayType(1, binaryen.i32, binaryen.notPacked, true);
+  builder.setArrayType(0, binaryen.Type.i32, binaryen.PackedType.i16, true);
+  builder.setArrayType(1, binaryen.Type.i32, binaryen.PackedType.notPacked, true);
   var [
     array0Type,
     array1Type
@@ -2582,8 +2582,8 @@ console.log("# ArrayNew");
 console.log("# ArrayNewFixed");
 (function testArrayNewFixed() {
   const builder = new binaryen.TypeBuilder(2);
-  builder.setArrayType(0, binaryen.i32, binaryen.i16, true);
-  builder.setArrayType(1, binaryen.i32, binaryen.notPacked, true);
+  builder.setArrayType(0, binaryen.Type.i32, binaryen.PackedType.i16, true);
+  builder.setArrayType(1, binaryen.Type.i32, binaryen.PackedType.notPacked, true);
   var [
     array0Type,
     array1Type
@@ -2644,8 +2644,8 @@ console.log("# ArrayNewFixed");
 console.log("# ArrayNewData");
 (function testArrayNewData() {
   const builder = new binaryen.TypeBuilder(2);
-  builder.setArrayType(0, binaryen.i32, binaryen.i16, true);
-  builder.setArrayType(1, binaryen.i32, binaryen.notPacked, true);
+  builder.setArrayType(0, binaryen.Type.i32, binaryen.PackedType.i16, true);
+  builder.setArrayType(1, binaryen.Type.i32, binaryen.PackedType.notPacked, true);
   var [
     array0Type,
     array1Type
@@ -2702,8 +2702,8 @@ console.log("# ArrayNewData");
 console.log("# ArrayNewElem");
 (function testArrayNewElem() {
   const builder = new binaryen.TypeBuilder(2);
-  builder.setArrayType(0, binaryen.i32, binaryen.i16, true);
-  builder.setArrayType(1, binaryen.i32, binaryen.notPacked, true);
+  builder.setArrayType(0, binaryen.Type.i32, binaryen.PackedType.i16, true);
+  builder.setArrayType(1, binaryen.Type.i32, binaryen.PackedType.notPacked, true);
   var [
     array0Type,
     array1Type
@@ -2761,8 +2761,8 @@ console.log("# ArrayNewElem");
 console.log("# ArrayGet");
 (function testArrayGet() {
   const builder = new binaryen.TypeBuilder(2);
-  builder.setArrayType(0, binaryen.i32, binaryen.i16, true);
-  builder.setArrayType(1, binaryen.i64, binaryen.notPacked, true);
+  builder.setArrayType(0, binaryen.Type.i32, binaryen.PackedType.i16, true);
+  builder.setArrayType(1, binaryen.Type.i64, binaryen.PackedType.notPacked, true);
   var [
     array0Type,
     array1Type
@@ -2772,7 +2772,7 @@ console.log("# ArrayGet");
 
   var ref = module.local.get(0, array0Type);
   var index = module.i32.const(0);
-  var type = binaryen.i32;
+  var type = binaryen.Type.i32;
   var signed = false;
   const theArrayGet = binaryen.ArrayGet(module.array.get(ref, index, type, signed));
   assert(theArrayGet instanceof binaryen.ArrayGet);
@@ -2795,7 +2795,7 @@ console.log("# ArrayGet");
   assert(theArrayGet.index === index);
   theArrayGet.signed = signed = true;
   assert(theArrayGet.signed === signed);
-  theArrayGet.type = type = binaryen.i64;
+  theArrayGet.type = type = binaryen.Type.i64;
   theArrayGet.finalize();
   assert(theArrayGet.type === type);
 
@@ -2818,8 +2818,8 @@ console.log("# ArrayGet");
 console.log("# ArraySet");
 (function testArraySet() {
   const builder = new binaryen.TypeBuilder(2);
-  builder.setArrayType(0, binaryen.i32, binaryen.i16, true);
-  builder.setArrayType(1, binaryen.i64, binaryen.notPacked, true);
+  builder.setArrayType(0, binaryen.Type.i32, binaryen.PackedType.i16, true);
+  builder.setArrayType(1, binaryen.Type.i64, binaryen.PackedType.notPacked, true);
   var [
     array0Type,
     array1Type
@@ -2829,14 +2829,14 @@ console.log("# ArraySet");
 
   var ref = module.local.get(0, array0Type);
   var index = module.i32.const(0);
-  var value = module.local.get(1, binaryen.i32);
+  var value = module.local.get(1, binaryen.Type.i32);
   const theArraySet = binaryen.ArraySet(module.array.set(ref, index, value));
   assert(theArraySet instanceof binaryen.ArraySet);
   assert(theArraySet instanceof binaryen.Expression);
   assert(theArraySet.ref === ref);
   assert(theArraySet.index === index);
   assert(theArraySet.value === value);
-  assert(theArraySet.type === binaryen.none);
+  assert(theArraySet.type === binaryen.Type.none);
 
   var info = binaryen.getExpressionInfo(theArraySet);
   assert(info.id === theArraySet.id);
@@ -2849,11 +2849,11 @@ console.log("# ArraySet");
   assert(theArraySet.ref === ref);
   theArraySet.index = index = module.i32.const(1);
   assert(theArraySet.index === index);
-  theArraySet.value = value = module.local.get(3, binaryen.i64);
+  theArraySet.value = value = module.local.get(3, binaryen.Type.i64);
   assert(theArraySet.value === value);
-  theArraySet.type = binaryen.i64;
+  theArraySet.type = binaryen.Type.i64;
   theArraySet.finalize();
-  assert(theArraySet.type === binaryen.none);
+  assert(theArraySet.type === binaryen.Type.none);
 
   info = binaryen.getExpressionInfo(theArraySet);
   assert(info.type === theArraySet.type);
@@ -2874,8 +2874,8 @@ console.log("# ArraySet");
 console.log("# ArrayLen");
 (function testArrayLen() {
   const builder = new binaryen.TypeBuilder(2);
-  builder.setArrayType(0, binaryen.i32, binaryen.i16, true);
-  builder.setArrayType(1, binaryen.i64, binaryen.notPacked, true);
+  builder.setArrayType(0, binaryen.Type.i32, binaryen.PackedType.i16, true);
+  builder.setArrayType(1, binaryen.Type.i64, binaryen.PackedType.notPacked, true);
   var [
     array0Type,
     array1Type
@@ -2888,7 +2888,7 @@ console.log("# ArrayLen");
   assert(theArrayLen instanceof binaryen.ArrayLen);
   assert(theArrayLen instanceof binaryen.Expression);
   assert(theArrayLen.ref === ref);
-  assert(theArrayLen.type === binaryen.i32);
+  assert(theArrayLen.type === binaryen.Type.i32);
 
   var info = binaryen.getExpressionInfo(theArrayLen);
   assert(info.id === theArrayLen.id);
@@ -2897,9 +2897,9 @@ console.log("# ArrayLen");
 
   theArrayLen.ref = ref = module.local.get(1, array1Type);
   assert(theArrayLen.ref === ref);
-  theArrayLen.type = binaryen.i64;
+  theArrayLen.type = binaryen.Type.i64;
   theArrayLen.finalize();
-  assert(theArrayLen.type === binaryen.i32);
+  assert(theArrayLen.type === binaryen.Type.i32);
 
   info = binaryen.getExpressionInfo(theArrayLen);
   assert(info.type === theArrayLen.type);
@@ -2918,8 +2918,8 @@ console.log("# ArrayLen");
 console.log("# ArrayFill");
 (function testArrayFill() {
   const builder = new binaryen.TypeBuilder(2);
-  builder.setArrayType(0, binaryen.i32, binaryen.i16, true);
-  builder.setArrayType(1, binaryen.i64, binaryen.notPacked, true);
+  builder.setArrayType(0, binaryen.Type.i32, binaryen.PackedType.i16, true);
+  builder.setArrayType(1, binaryen.Type.i64, binaryen.PackedType.notPacked, true);
   var [
     array0Type,
     array1Type
@@ -2929,7 +2929,7 @@ console.log("# ArrayFill");
 
   var ref = module.local.get(0, array0Type);
   var index = module.i32.const(0);
-  var value = module.local.get(1, binaryen.i32);
+  var value = module.local.get(1, binaryen.Type.i32);
   var size = module.i32.const(1);
   const theArrayFill = binaryen.ArrayFill(module.array.fill(ref, index, value, size));
   assert(theArrayFill instanceof binaryen.ArrayFill);
@@ -2938,7 +2938,7 @@ console.log("# ArrayFill");
   assert(theArrayFill.index === index);
   assert(theArrayFill.value === value);
   assert(theArrayFill.size === size);
-  assert(theArrayFill.type === binaryen.none);
+  assert(theArrayFill.type === binaryen.Type.none);
 
   var info = binaryen.getExpressionInfo(theArrayFill);
   assert(info.id === theArrayFill.id);
@@ -2952,13 +2952,13 @@ console.log("# ArrayFill");
   assert(theArrayFill.ref === ref);
   theArrayFill.index = index = module.i32.const(2);
   assert(theArrayFill.index === index);
-  theArrayFill.value = value = module.local.get(3, binaryen.i64);
+  theArrayFill.value = value = module.local.get(3, binaryen.Type.i64);
   assert(theArrayFill.value = value);
   theArrayFill.size = size = module.i32.const(3);
   assert(theArrayFill.size === size);
-  theArrayFill.type = binaryen.i64;
+  theArrayFill.type = binaryen.Type.i64;
   theArrayFill.finalize();
-  assert(theArrayFill.type === binaryen.none);
+  assert(theArrayFill.type === binaryen.Type.none);
 
   info = binaryen.getExpressionInfo(theArrayFill);
   assert(info.type === theArrayFill.type);
@@ -2980,8 +2980,8 @@ console.log("# ArrayFill");
 console.log("# ArrayCopy");
 (function testArrayCopy() {
   const builder = new binaryen.TypeBuilder(2);
-  builder.setArrayType(0, binaryen.i32, binaryen.i16, true);
-  builder.setArrayType(1, binaryen.i64, binaryen.notPacked, true);
+  builder.setArrayType(0, binaryen.Type.i32, binaryen.PackedType.i16, true);
+  builder.setArrayType(1, binaryen.Type.i64, binaryen.PackedType.notPacked, true);
   var [
     array0Type,
     array1Type
@@ -3002,7 +3002,7 @@ console.log("# ArrayCopy");
   assert(theArrayCopy.srcRef === srcRef);
   assert(theArrayCopy.srcIndex === srcIndex);
   assert(theArrayCopy.length === length);
-  assert(theArrayCopy.type === binaryen.none);
+  assert(theArrayCopy.type === binaryen.Type.none);
 
   var info = binaryen.getExpressionInfo(theArrayCopy);
   assert(info.id === theArrayCopy.id);
@@ -3023,9 +3023,9 @@ console.log("# ArrayCopy");
   assert(theArrayCopy.srcIndex === srcIndex);
   theArrayCopy.length = length = module.i32.const(2);
   assert(theArrayCopy.length === length);
-  theArrayCopy.type = binaryen.i64;
+  theArrayCopy.type = binaryen.Type.i64;
   theArrayCopy.finalize();
-  assert(theArrayCopy.type === binaryen.none);
+  assert(theArrayCopy.type === binaryen.Type.none);
 
   info = binaryen.getExpressionInfo(theArrayCopy);
   assert(info.type === theArrayCopy.type);
@@ -3048,8 +3048,8 @@ console.log("# ArrayCopy");
 console.log("# ArrayInitData");
 (function testArrayInitData() {
   const builder = new binaryen.TypeBuilder(2);
-  builder.setArrayType(0, binaryen.i32, binaryen.i16, true);
-  builder.setArrayType(1, binaryen.i32, binaryen.notPacked, true);
+  builder.setArrayType(0, binaryen.Type.i32, binaryen.PackedType.i16, true);
+  builder.setArrayType(1, binaryen.Type.i32, binaryen.PackedType.notPacked, true);
   var [
     array0Type,
     array1Type
@@ -3070,7 +3070,7 @@ console.log("# ArrayInitData");
   assert(theArrayInitData.index === index);
   assert(theArrayInitData.offset === offset);
   assert(theArrayInitData.size === size);
-  assert(theArrayInitData.type === binaryen.none);
+  assert(theArrayInitData.type === binaryen.Type.none);
   
   var info = binaryen.getExpressionInfo(theArrayInitData);
   assert(info.id === theArrayInitData.id);
@@ -3091,9 +3091,9 @@ console.log("# ArrayInitData");
   assert(theArrayInitData.offset === offset);
   theArrayInitData.size = size = module.i32.const(5);
   assert(theArrayInitData.size === size);
-  theArrayInitData.type = binaryen.i64;
+  theArrayInitData.type = binaryen.Type.i64;
   theArrayInitData.finalize();
-  assert(theArrayInitData.type === binaryen.none);
+  assert(theArrayInitData.type === binaryen.Type.none);
 
   info = binaryen.getExpressionInfo(theArrayInitData);
   assert(info.type === theArrayInitData.type);
@@ -3116,8 +3116,8 @@ console.log("# ArrayInitData");
 console.log("# ArrayInitElem");
 (function testArrayInitElem() {
   const builder = new binaryen.TypeBuilder(2);
-  builder.setArrayType(0, binaryen.i32, binaryen.i16, true);
-  builder.setArrayType(1, binaryen.i32, binaryen.notPacked, true);
+  builder.setArrayType(0, binaryen.Type.i32, binaryen.PackedType.i16, true);
+  builder.setArrayType(1, binaryen.Type.i32, binaryen.PackedType.notPacked, true);
   var [
     array0Type,
     array1Type
@@ -3138,7 +3138,7 @@ console.log("# ArrayInitElem");
   assert(theArrayInitElem.index === index);
   assert(theArrayInitElem.offset === offset);
   assert(theArrayInitElem.size === size);
-  assert(theArrayInitElem.type === binaryen.none);
+  assert(theArrayInitElem.type === binaryen.Type.none);
 
   var info = binaryen.getExpressionInfo(theArrayInitElem);
   assert(info.id === theArrayInitElem.id);
@@ -3159,9 +3159,9 @@ console.log("# ArrayInitElem");
   assert(theArrayInitElem.offset === offset);
   theArrayInitElem.size = size = module.i32.const(5);
   assert(theArrayInitElem.size === size);
-  theArrayInitElem.type = binaryen.i64;
+  theArrayInitElem.type = binaryen.Type.i64;
   theArrayInitElem.finalize();
-  assert(theArrayInitElem.type === binaryen.none);
+  assert(theArrayInitElem.type === binaryen.Type.none);
 
   info = binaryen.getExpressionInfo(theArrayInitElem);
   assert(info.type === theArrayInitElem.type);
@@ -3184,9 +3184,9 @@ console.log("# ArrayInitElem");
 console.log("# Try");
 (function testTry() {
   const module = new binaryen.Module();
-  module.addTag("tag1", 0, binaryen.none, binaryen.none);
-  module.addTag("tag2", 0, binaryen.none, binaryen.none);
-  module.addTag("tag3", 0, binaryen.none, binaryen.none);
+  module.addTag("tag1", 0, binaryen.Type.none, binaryen.Type.none);
+  module.addTag("tag2", 0, binaryen.Type.none, binaryen.Type.none);
+  module.addTag("tag3", 0, binaryen.Type.none, binaryen.Type.none);
 
   var body = module.i32.const(1);
   var catchBodies = [
@@ -3198,7 +3198,7 @@ console.log("# Try");
   assert(theTry instanceof binaryen.Expression);
   assert(theTry.body === body);
   assertDeepEqual(theTry.catchBodies, catchBodies);
-  assert(theTry.type === binaryen.i32);
+  assert(theTry.type === binaryen.Type.i32);
   assert(theTry.getNumCatchTags() == 1);
   assert(theTry.getNumCatchBodies() == 2);
   assert(theTry.hasCatchAll() == 1);
@@ -3253,9 +3253,9 @@ console.log("# Try");
   assert(theTry.getCatchTagAt(1) == "tag1");
   console.log(theTry.toText());
 
-  theTry.type = binaryen.f64;
+  theTry.type = binaryen.Type.f64;
   theTry.finalize();
-  assert(theTry.type === binaryen.i32);
+  assert(theTry.type === binaryen.Type.i32);
 
   info = binaryen.getExpressionInfo(theTry);
   assert(info.id === theTry.id);
@@ -3288,8 +3288,8 @@ console.log("# Try");
 console.log("# TryTable");
 (function testTryTable() {
   const module = new binaryen.Module();
-  module.addTag("tag1", 0, binaryen.none, binaryen.none);
-  module.addTag("tag2", 0, binaryen.none, binaryen.none);
+  module.addTag("tag1", 0, binaryen.Type.none, binaryen.Type.none);
+  module.addTag("tag2", 0, binaryen.Type.none, binaryen.Type.none);
 
   var body = module.nop();
   var catches = [
@@ -3345,7 +3345,7 @@ console.log("# TryTable");
   assertDeepEqual(theTryTable.catches, newCatches);
   console.log(theTryTable.toText());
 
-  theTryTable.type = binaryen.f64;
+  theTryTable.type = binaryen.Type.f64;
   theTryTable.finalize();
   console.log(theTryTable.toText());
 
@@ -3366,7 +3366,7 @@ console.log("# Throw");
   assert(theThrow instanceof binaryen.Expression);
   assert(theThrow.tag === tag);
   assertDeepEqual(theThrow.operands, operands);
-  assert(theThrow.type === binaryen.unreachable);
+  assert(theThrow.type === binaryen.Type.unreachable);
 
   var info = binaryen.getExpressionInfo(theThrow);
   assert(info.id === theThrow.id);
@@ -3391,9 +3391,9 @@ console.log("# Throw");
   theThrow.setOperands(operands);
   assertDeepEqual(theThrow.operands, operands);
   theThrow.insertOperandAt(1, module.i32.const(7));
-  theThrow.type = binaryen.f64;
+  theThrow.type = binaryen.Type.f64;
   theThrow.finalize();
-  assert(theThrow.type === binaryen.unreachable);
+  assert(theThrow.type === binaryen.Type.unreachable);
 
   info = binaryen.getExpressionInfo(theThrow);
   assert(info.type === theThrow.type);
@@ -3418,7 +3418,7 @@ console.log("# Rethrow");
   assert(theRethrow instanceof binaryen.Rethrow);
   assert(theRethrow instanceof binaryen.Expression);
   assert(theRethrow.target === "l0");
-  assert(theRethrow.type === binaryen.unreachable);
+  assert(theRethrow.type === binaryen.Type.unreachable);
 
   var info = binaryen.getExpressionInfo(theRethrow);
   assert(info.id === theRethrow.id);
@@ -3427,9 +3427,9 @@ console.log("# Rethrow");
 
   theRethrow.target = "l1";
   assert(theRethrow.target === "l1");
-  theRethrow.type = binaryen.f64;
+  theRethrow.type = binaryen.Type.f64;
   theRethrow.finalize();
-  assert(theRethrow.type === binaryen.unreachable);
+  assert(theRethrow.type === binaryen.Type.unreachable);
 
   info = binaryen.getExpressionInfo(theRethrow);
   assert(info.type === theRethrow.type);
@@ -3449,25 +3449,25 @@ console.log("# ThrowRef");
 (function testThrowRef() {
   const module = new binaryen.Module();
 
-  var exnref = module.ref.null(binaryen.noexn);
+  var exnref = module.ref.null(binaryen.HeapType.noexn);
   const theThrowRef = binaryen.ThrowRef(module.throw_ref(exnref));
   assert(theThrowRef instanceof binaryen.ThrowRef);
   assert(theThrowRef instanceof binaryen.Expression);
   assert(theThrowRef.exnref === exnref);
-  assert(theThrowRef.type === binaryen.unreachable);
+  assert(theThrowRef.type === binaryen.Type.unreachable);
 
   var info = binaryen.getExpressionInfo(theThrowRef);
   assert(info.id === theThrowRef.id);
   assert(info.type === theThrowRef.type);
   assert(info.exnref === theThrowRef.exnref);
 
-  var newExnref = module.ref.null(binaryen.noexn);
+  var newExnref = module.ref.null(binaryen.HeapType.noexn);
   theThrowRef.exnref = newExnref;
   assert(theThrowRef.exnref === newExnref);
 
-  theThrowRef.type = binaryen.f64;
+  theThrowRef.type = binaryen.Type.f64;
   theThrowRef.finalize();
-  assert(theThrowRef.type === binaryen.unreachable);
+  assert(theThrowRef.type === binaryen.Type.unreachable);
 
   console.log(theThrowRef.toText());
 
@@ -3482,7 +3482,7 @@ console.log("# TupleMake");
     module.i32.const(1),
     module.i32.const(2)
   ];
-  var type = binaryen.createType([ binaryen.i32, binaryen.i32 ]);
+  var type = binaryen.createType([ binaryen.Type.i32, binaryen.Type.i32 ]);
   const theTupleMake = binaryen.TupleMake(module.tuple.make(operands));
   assert(theTupleMake instanceof binaryen.TupleMake);
   assert(theTupleMake instanceof binaryen.Expression);
@@ -3509,7 +3509,7 @@ console.log("# TupleMake");
   assertDeepEqual(theTupleMake.operands, operands);
   assertDeepEqual(theTupleMake.getOperands(), operands);
   theTupleMake.insertOperandAt(1, module.i32.const(7));
-  theTupleMake.type = binaryen.f64;
+  theTupleMake.type = binaryen.Type.f64;
   theTupleMake.finalize();
   assert(theTupleMake.type === type);
 
@@ -3541,7 +3541,7 @@ console.log("# TupleExtract");
   assert(theTupleExtract instanceof binaryen.Expression);
   assert(theTupleExtract.tuple === tuple);
   assert(theTupleExtract.index === index);
-  assert(theTupleExtract.type === binaryen.i32);
+  assert(theTupleExtract.type === binaryen.Type.i32);
 
   var info = binaryen.getExpressionInfo(theTupleExtract);
   assert(info.id === theTupleExtract.id);
@@ -3556,9 +3556,9 @@ console.log("# TupleExtract");
   assert(theTupleExtract.tuple === tuple);
   theTupleExtract.index = index = 0;
   assert(theTupleExtract.index === index);
-  theTupleExtract.type = binaryen.i32;
+  theTupleExtract.type = binaryen.Type.i32;
   theTupleExtract.finalize();
-  assert(theTupleExtract.type === binaryen.f64);
+  assert(theTupleExtract.type === binaryen.Type.f64);
 
   info = binaryen.getExpressionInfo(theTupleExtract);
   assert(info.type === theTupleExtract.type);
@@ -3579,7 +3579,7 @@ console.log("# RefI31");
 (function testRefI31() {
   const module = new binaryen.Module();
 
-  var value = module.local.get(1, binaryen.i32);
+  var value = module.local.get(1, binaryen.Type.i32);
   const theRefI31 = binaryen.RefI31(module.ref.i31(value));
   assert(theRefI31 instanceof binaryen.RefI31);
   assert(theRefI31 instanceof binaryen.Expression);
@@ -3591,7 +3591,7 @@ console.log("# RefI31");
   assert(info.type === theRefI31.type);
   assert(info.value === theRefI31.value);
 
-  theRefI31.value = value = module.local.get(2, binaryen.i32);
+  theRefI31.value = value = module.local.get(2, binaryen.Type.i32);
   assert(theRefI31.value === value);
 
   info = binaryen.getExpressionInfo(theRefI31);
@@ -3611,13 +3611,13 @@ console.log("# I31Get");
 (function testI31Get() {
   const module = new binaryen.Module();
 
-  var i31 = module.local.get(1, binaryen.i31ref);
+  var i31 = module.local.get(1, binaryen.Type.i31ref);
   const theI31Get = binaryen.I31Get(module.i31.get_s(i31));
   assert(theI31Get instanceof binaryen.I31Get);
   assert(theI31Get instanceof binaryen.Expression);
   assert(theI31Get.i31 === i31);
   assert(theI31Get.signed === true);
-  assert(theI31Get.type === binaryen.i32);
+  assert(theI31Get.type === binaryen.Type.i32);
 
   var info = binaryen.getExpressionInfo(theI31Get);
   assert(info.id === theI31Get.id);
@@ -3625,13 +3625,13 @@ console.log("# I31Get");
   assert(info.i31 === theI31Get.i31);
   assert(info.isSigned === theI31Get.signed);
 
-  theI31Get.i31 = i31 = module.local.get(2, binaryen.i31ref);
+  theI31Get.i31 = i31 = module.local.get(2, binaryen.Type.i31ref);
   assert(theI31Get.i31 === i31);
   theI31Get.signed = false;
   assert(theI31Get.signed === false);
-  theI31Get.type = binaryen.f64;
+  theI31Get.type = binaryen.Type.f64;
   theI31Get.finalize();
-  assert(theI31Get.type === binaryen.i32);
+  assert(theI31Get.type === binaryen.Type.i32);
 
   info = binaryen.getExpressionInfo(theI31Get);
   assert(info.type === theI31Get.type);
@@ -3653,7 +3653,7 @@ console.log("# CallRef");
   const module = new binaryen.Module();
 
   const funcName = "tiny";
-  module.addFunction(funcName, binaryen.createType([binaryen.i32, binaryen.i32]), binaryen.none, [], module.nop());
+  module.addFunction(funcName, binaryen.createType([binaryen.Type.i32, binaryen.Type.i32]), binaryen.Type.none, [], module.nop());
   const funcType = binaryen.Function(module.getFunction(funcName)).type;
   const funcRef = binaryen.RefFunc(module.ref.func(funcName, funcType));
 
@@ -3662,11 +3662,11 @@ console.log("# CallRef");
     module.i32.const(7)
   ];
 
-  const theCallRef = binaryen.CallRef(module.call_ref(funcRef, operands, binaryen.none));
+  const theCallRef = binaryen.CallRef(module.call_ref(funcRef, operands, binaryen.Type.none));
   assert(theCallRef instanceof binaryen.CallRef);
   assert(theCallRef instanceof binaryen.Expression);
   assert(theCallRef.numOperands === operands.length);
-  assert(theCallRef.type === binaryen.none);
+  assert(theCallRef.type === binaryen.Type.none);
   assert(binaryen.RefFunc(theCallRef.target).func === funcName);
 
   const info = binaryen.getExpressionInfo(theCallRef);
@@ -3712,7 +3712,7 @@ console.log("# CallRef");
   theCallRef.setReturn(false);
   assert(theCallRef.isReturn() === false);
 
-  const theReturnCallRef = binaryen.CallRef(module.return_call_ref(funcRef, operands, binaryen.none));
+  const theReturnCallRef = binaryen.CallRef(module.return_call_ref(funcRef, operands, binaryen.Type.none));
   assert(theReturnCallRef instanceof binaryen.CallRef);
   assert(theReturnCallRef instanceof binaryen.Expression);
   assert(theReturnCallRef.numOperands === operands.length);
diff --git a/test/binaryen.js/functions.js b/test/binaryen.js/functions.js
index 84f59350bf1..45252162a4f 100644
--- a/test/binaryen.js/functions.js
+++ b/test/binaryen.js/functions.js
@@ -10,7 +10,7 @@ function cleanInfo(info) {
 
 var module = new binaryen.Module();
 
-var func = module.addFunction("a-function", binaryen.none, binaryen.i32, [],
+var func = module.addFunction("a-function", binaryen.Type.none, binaryen.Type.i32, [],
   module.i32.add(
     module.i32.const(1),
     module.i32.const(2)
@@ -36,15 +36,15 @@ console.log(module.emitText());
 // Test wrapper
 
 func = module.addFunction("b-function",
-  binaryen.createType([binaryen.i32, binaryen.i32]),
-  binaryen.i32,
-  [ binaryen.i32, binaryen.f64 ],
+  binaryen.createType([binaryen.Type.i32, binaryen.Type.i32]),
+  binaryen.Type.i32,
+  [ binaryen.Type.i32, binaryen.Type.f64 ],
   module.local.tee(2,
     module.i32.add(
-      module.local.get(0, binaryen.i32),
-      module.local.get(1, binaryen.i32)
+      module.local.get(0, binaryen.Type.i32),
+      module.local.get(1, binaryen.Type.i32)
     ),
-    binaryen.i32
+    binaryen.Type.i32
   )
 );
 binaryen.Function.setLocalName(func, 0, "a");
@@ -54,11 +54,11 @@ binaryen.Function.setLocalName(func, 3, "unused");
 
 var theFunc = binaryen.Function(func);
 assert(theFunc.name === "b-function");
-assert(theFunc.params === binaryen.createType([binaryen.i32, binaryen.i32]));
-assert(theFunc.results === binaryen.i32);
+assert(theFunc.params === binaryen.createType([binaryen.Type.i32, binaryen.Type.i32]));
+assert(theFunc.results === binaryen.Type.i32);
 assert(theFunc.numVars === 2);
-assert(theFunc.getVar(0) === binaryen.i32);
-assert(theFunc.getVar(1) === binaryen.f64);
+assert(theFunc.getVar(0) === binaryen.Type.i32);
+assert(theFunc.getVar(1) === binaryen.Type.f64);
 assert(theFunc.numLocals === 4);
 assert(theFunc.getLocalName(0) === "a");
 assert(theFunc.getLocalName(1) === "b");
diff --git a/test/binaryen.js/gc.js b/test/binaryen.js/gc.js
index cf3c8ab4009..9bb5df54506 100644
--- a/test/binaryen.js/gc.js
+++ b/test/binaryen.js/gc.js
@@ -1,11 +1,11 @@
 var builder = new binaryen.TypeBuilder(4);
-builder.setSignatureType(0, binaryen.createType([binaryen.i32]), binaryen.none);
+builder.setSignatureType(0, binaryen.createType([binaryen.Type.i32]), binaryen.Type.none);
 builder.setStructType(1, [
-  { type: binaryen.i32, packedType: binaryen.i16, mutable: true },
-  { type: binaryen.f64, packedType: binaryen.notPacked, mutable: true }
+  { type: binaryen.Type.i32, packedType: binaryen.PackedType.i16, mutable: true },
+  { type: binaryen.Type.f64, packedType: binaryen.PackedType.notPacked, mutable: true }
 ]);
-builder.setArrayType(2, binaryen.i32, binaryen.i8, true);
-builder.setArrayType(3, binaryen.funcref, binaryen.notPacked, true);
+builder.setArrayType(2, binaryen.Type.i32, binaryen.PackedType.i8, true);
+builder.setArrayType(3, binaryen.Type.funcref, binaryen.PackedType.notPacked, true);
 var [
   signatureHeapType,
   structHeapType,
@@ -21,10 +21,10 @@ var funcArrayType = binaryen.getTypeFromHeapType(funcArrayHeapType, true);
 var module = new binaryen.Module();
 module.setFeatures(binaryen.Features.ReferenceTypes | binaryen.Features.BulkMemory | binaryen.Features.GC | binaryen.Features.Strings);
 
-module.addFunction("add", binaryen.createType([binaryen.i32, binaryen.i32]), binaryen.i32, [],
+module.addFunction("add", binaryen.createType([binaryen.Type.i32, binaryen.Type.i32]), binaryen.Type.i32, [],
   module.i32.add(
-    module.local.get("0", binaryen.i32),
-    module.local.get("1", binaryen.i32)
+    module.local.get("0", binaryen.Type.i32),
+    module.local.get("1", binaryen.Type.i32)
   )
 );
 
@@ -78,7 +78,7 @@ var valueList = [
   module.struct.get(
     0,
     module.global.get("struct-global", structType),
-    binaryen.i32,
+    binaryen.Type.i32,
     true
   ),
   module.struct.set(
@@ -120,7 +120,7 @@ var valueList = [
   module.array.get(
     module.global.get("array-global", arrayType),
     module.i32.const(0),
-    binaryen.i32,
+    binaryen.Type.i32,
     true
   ),
   module.array.set(
@@ -162,17 +162,17 @@ var valueList = [
   // string
   module.string.const("hello 🌎"),
 ];
-module.addFunction("main", binaryen.none, binaryen.none, [],
+module.addFunction("main", binaryen.Type.none, binaryen.Type.none, [],
   module.block(
     null,
     valueList.map(value => {
       var type = binaryen.getExpressionType(value);
-      if (type === binaryen.none || type === binaryen.unreachable)
+      if (type === binaryen.Type.none || type === binaryen.Type.unreachable)
         return value;
       else
         return module.drop(value);
     }),
-    binaryen.none
+    binaryen.Type.none
   )
 );
 
diff --git a/test/binaryen.js/global.js b/test/binaryen.js/global.js
index b0baf25999d..0f07aae9f08 100644
--- a/test/binaryen.js/global.js
+++ b/test/binaryen.js/global.js
@@ -12,7 +12,7 @@ var module = new binaryen.Module();
 module.setFeatures(binaryen.Features.MVP | binaryen.Features.MutableGlobals);
 
 var initExpr = module.i32.const(1);
-var global = module.addGlobal("a-global", binaryen.i32, false, initExpr);
+var global = module.addGlobal("a-global", binaryen.Type.i32, false, initExpr);
 
 console.log("GetGlobal is equal: " + (global === module.getGlobal("a-global")));
 
@@ -24,8 +24,8 @@ console.log("getExpressionInfo(init)=" + JSON.stringify(cleanInfo(initExpInfo)))
 console.log(binaryen.emitText(globalInfo.init));
 
 module.addGlobalExport("a-global", "a-global-exp");
-module.addGlobalImport("a-global-imp", "module", "base", binaryen.i32, false);
-module.addGlobalImport("a-mut-global-imp", "module", "base", binaryen.i32, true);
+module.addGlobalImport("a-global-imp", "module", "base", binaryen.Type.i32, false);
+module.addGlobalImport("a-mut-global-imp", "module", "base", binaryen.Type.i32, true);
 
 assert(module.validate());
 console.log(module.emitText());
diff --git a/test/binaryen.js/hello-world.js b/test/binaryen.js/hello-world.js
index d82de61162d..47a6b5bf5e3 100644
--- a/test/binaryen.js/hello-world.js
+++ b/test/binaryen.js/hello-world.js
@@ -6,15 +6,15 @@ var module = new binaryen.Module();
 
 // Start to create the function, starting with the contents: Get the 0 and
 // 1 arguments, and add them, then return them
-var left = module.local.get(0, binaryen.i32);
-var right = module.local.get(1, binaryen.i32);
+var left = module.local.get(0, binaryen.Type.i32);
+var right = module.local.get(1, binaryen.Type.i32);
 var add = module.i32.add(left, right);
 var ret = module.return(add);
 
 // Create the add function
 // Note: no additional local variables (that's the [])
-var ii = binaryen.createType([binaryen.i32, binaryen.i32])
-module.addFunction('adder', ii, binaryen.i32, [], ret);
+var ii = binaryen.createType([binaryen.Type.i32, binaryen.Type.i32])
+module.addFunction('adder', ii, binaryen.Type.i32, [], ret);
 
 // Export the function, so we can call it later (for simplicity we
 // export it as the same name as it has internally)
diff --git a/test/binaryen.js/kitchen-sink.js b/test/binaryen.js/kitchen-sink.js
index b558da24a9e..8ebc2bdfa3a 100644
--- a/test/binaryen.js/kitchen-sink.js
+++ b/test/binaryen.js/kitchen-sink.js
@@ -47,38 +47,38 @@ function makeDroppedInt32(x) {
 // tests
 
 function test_types() {
-  console.log("  // BinaryenTypeNone: " + binaryen.none);
-  console.log("  //", binaryen.expandType(binaryen.none).join(","));
+  console.log("  // BinaryenTypeNone: " + binaryen.Type.none);
+  console.log("  //", binaryen.expandType(binaryen.Type.none).join(","));
 
-  console.log("  // BinaryenTypeUnreachable: " + binaryen.unreachable);
-  console.log("  //", binaryen.expandType(binaryen.unreachable).join(","));
+  console.log("  // BinaryenTypeUnreachable: " + binaryen.Type.unreachable);
+  console.log("  //", binaryen.expandType(binaryen.Type.unreachable).join(","));
 
-  console.log("  // BinaryenTypeInt32: " + binaryen.i32);
-  console.log("  //", binaryen.expandType(binaryen.i32).join(","));
+  console.log("  // BinaryenTypeInt32: " + binaryen.Type.i32);
+  console.log("  //", binaryen.expandType(binaryen.Type.i32).join(","));
 
-  console.log("  // BinaryenTypeInt64: " + binaryen.i64);
-  console.log("  //", binaryen.expandType(binaryen.i64).join(","));
+  console.log("  // BinaryenTypeInt64: " + binaryen.Type.i64);
+  console.log("  //", binaryen.expandType(binaryen.Type.i64).join(","));
 
-  console.log("  // BinaryenTypeFloat32: " + binaryen.f32);
-  console.log("  //", binaryen.expandType(binaryen.f32).join(","));
+  console.log("  // BinaryenTypeFloat32: " + binaryen.Type.f32);
+  console.log("  //", binaryen.expandType(binaryen.Type.f32).join(","));
 
-  console.log("  // BinaryenTypeFloat64: " + binaryen.f64);
-  console.log("  //", binaryen.expandType(binaryen.f64).join(","));
+  console.log("  // BinaryenTypeFloat64: " + binaryen.Type.f64);
+  console.log("  //", binaryen.expandType(binaryen.Type.f64).join(","));
 
-  console.log("  // BinaryenTypeVec128: " + binaryen.v128);
-  console.log("  //", binaryen.expandType(binaryen.v128).join(","));
+  console.log("  // BinaryenTypeVec128: " + binaryen.Type.v128);
+  console.log("  //", binaryen.expandType(binaryen.Type.v128).join(","));
 
-  console.log("  // BinaryenTypeAuto: " + binaryen.auto);
+  console.log("  // BinaryenTypeAuto: " + binaryen.Type.auto);
 
-  var i32_pair = binaryen.createType([binaryen.i32, binaryen.i32]);
+  var i32_pair = binaryen.createType([binaryen.Type.i32, binaryen.Type.i32]);
   console.log("  //", binaryen.expandType(i32_pair).join(","));
 
-  var duplicate_pair = binaryen.createType([binaryen.i32, binaryen.i32]);
+  var duplicate_pair = binaryen.createType([binaryen.Type.i32, binaryen.Type.i32]);
   console.log("  //", binaryen.expandType(duplicate_pair).join(","));
 
   assert(i32_pair == duplicate_pair);
 
-  var f32_pair = binaryen.createType([binaryen.f32, binaryen.f32]);
+  var f32_pair = binaryen.createType([binaryen.Type.f32, binaryen.Type.f32]);
   console.log("  //", binaryen.expandType(f32_pair).join(","));
 }
 
@@ -212,7 +212,7 @@ function test_core() {
   ], true);
 
   // Create a tag
-  var tag = module.addTag("a-tag", binaryen.i32, binaryen.none);
+  var tag = module.addTag("a-tag", binaryen.Type.i32, binaryen.Type.none);
 
   // Literals and consts
 
@@ -223,7 +223,7 @@ function test_core() {
       constF32Bits = module.f32.const_bits(0xffff1234),
       constF64Bits = module.f64.const_bits(0xffff1234_5678abcdn);
 
-  var iIfF = binaryen.createType([binaryen.i32, binaryen.i64, binaryen.f32, binaryen.f64])
+  var iIfF = binaryen.createType([binaryen.Type.i32, binaryen.Type.i64, binaryen.Type.f32, binaryen.Type.f64])
 
   var temp1 = makeInt32(1), temp2 = makeInt32(2), temp3 = makeInt32(3),
       temp4 = makeInt32(4), temp5 = makeInt32(5),
@@ -234,7 +234,7 @@ function test_core() {
       temp15 = makeInt32(110), temp16 = makeInt64(111);
 
   // Create a function to reference.
-  module.addFunction("foobar", iIfF, binaryen.i32, [], module.i32.const(0));
+  module.addFunction("foobar", iIfF, binaryen.Type.i32, [], module.i32.const(0));
   var foobarType = binaryen.Function(module.getFunction("foobar")).getType();
 
   var valueList = [
@@ -580,19 +580,19 @@ function test_core() {
     module.switch([ "the-value" ], "the-value", temp8, temp9),
     module.switch([ "the-nothing" ], "the-nothing", makeInt32(2)),
     module.i32.eqz( // check the output type of the call node
-      module.call("kitchen()sinker", [ makeInt32(13), makeInt64(37, 0), makeFloat32(1.3), makeFloat64(3.7) ], binaryen.i32)
+      module.call("kitchen()sinker", [ makeInt32(13), makeInt64(37, 0), makeFloat32(1.3), makeFloat64(3.7) ], binaryen.Type.i32)
     ),
     module.i32.eqz( // check the output type of the call node
       module.i32.trunc_s.f32(
-        module.call("an-imported", [ makeInt32(13), makeFloat64(3.7) ], binaryen.f32)
+        module.call("an-imported", [ makeInt32(13), makeFloat64(3.7) ], binaryen.Type.f32)
       )
     ),
     module.i32.eqz( // check the output type of the call node
-      module.call_indirect("t0", makeInt32(2449), [ makeInt32(13), makeInt64(37, 0), makeFloat32(1.3), makeFloat64(3.7) ], iIfF, binaryen.i32)
+      module.call_indirect("t0", makeInt32(2449), [ makeInt32(13), makeInt64(37, 0), makeFloat32(1.3), makeFloat64(3.7) ], iIfF, binaryen.Type.i32)
     ),
-    module.drop(module.local.get(0, binaryen.i32)),
+    module.drop(module.local.get(0, binaryen.Type.i32)),
     module.local.set(0, makeInt32(101)),
-    module.drop(module.local.tee(0, makeInt32(102), binaryen.i32)),
+    module.drop(module.local.tee(0, makeInt32(102), binaryen.Type.i32)),
     module.i32.load(0, 0, makeInt32(1)),
     module.i64.load16_s(2, 1, makeInt32(8)),
     module.f32.load(0, 0, makeInt32(2)),
@@ -602,17 +602,17 @@ function test_core() {
     module.select(temp10, temp11, temp12),
     module.return(makeInt32(1337)),
     // Tail Call
-    module.return_call("kitchen()sinker", [ makeInt32(13), makeInt64(37, 0), makeFloat32(1.3), makeFloat64(3.7) ], binaryen.i32),
-    module.return_call_indirect("t0", makeInt32(2449), [ makeInt32(13), makeInt64(37, 0), makeFloat32(1.3), makeFloat64(3.7) ], iIfF, binaryen.i32),
+    module.return_call("kitchen()sinker", [ makeInt32(13), makeInt64(37, 0), makeFloat32(1.3), makeFloat64(3.7) ], binaryen.Type.i32),
+    module.return_call_indirect("t0", makeInt32(2449), [ makeInt32(13), makeInt64(37, 0), makeFloat32(1.3), makeFloat64(3.7) ], iIfF, binaryen.Type.i32),
 
     // Reference types
-    module.ref.is_null(module.ref.null(binaryen.extern)),
-    module.ref.is_null(module.ref.null(binaryen.func)),
+    module.ref.is_null(module.ref.null(binaryen.HeapType.extern)),
+    module.ref.is_null(module.ref.null(binaryen.HeapType.func)),
     module.ref.is_null(module.ref.func("foobar", foobarType)),
-    module.select(temp10, module.ref.null(binaryen.func), module.ref.func("foobar", foobarType)),
+    module.select(temp10, module.ref.null(binaryen.HeapType.func), module.ref.func("foobar", foobarType)),
 
     // GC
-    module.ref.eq(module.ref.null(binaryen.eq), module.ref.null(binaryen.eq)),
+    module.ref.eq(module.ref.null(binaryen.HeapType.eq), module.ref.null(binaryen.HeapType.eq)),
 
     // Exception handling
     module.try(
@@ -711,7 +711,7 @@ function test_core() {
   // Add drops of concrete expressions, except the last.
   for (var i = 0; i < valueList.length - 1; i++) {
     var type = binaryen.Expression.getType(valueList[i]);
-    if (type != binaryen.none && type != binaryen.unreachable) {
+    if (type != binaryen.Type.none && type != binaryen.Type.unreachable) {
       valueList[i] = module.drop(valueList[i]);
     }
   }
@@ -737,25 +737,25 @@ function test_core() {
   }
 
   // Make the main body of the function. and one block with a return value, one without
-  var value = module.block("the-value", valueList, binaryen.i32);
+  var value = module.block("the-value", valueList, binaryen.Type.i32);
   var droppedValue = module.drop(value);
   var nothing = module.block("the-nothing", [ droppedValue ]);
-  var body = module.block("the-body", [ nothing, makeInt32(42) ], binaryen.i32);
+  var body = module.block("the-body", [ nothing, makeInt32(42) ], binaryen.Type.i32);
 
   // Create the function
-  var sinker = module.addFunction("kitchen()sinker", iIfF, binaryen.i32, [ binaryen.i32 ], body);
+  var sinker = module.addFunction("kitchen()sinker", iIfF, binaryen.Type.i32, [ binaryen.Type.i32 ], body);
 
   // Create a global
   var initExpr = module.i32.const(1);
-  var global = module.addGlobal("a-global", binaryen.i32, false, initExpr)
+  var global = module.addGlobal("a-global", binaryen.Type.i32, false, initExpr)
 
   // Imports
 
-  var iF = binaryen.createType([binaryen.i32, binaryen.f64]);
-  module.addFunctionImport("an-imported", "module", "base", iF, binaryen.f32);
-  module.addGlobalImport("a-global-imp", "module", "base", binaryen.i32, false);
-  module.addGlobalImport("a-mut-global-imp", "module", "base", binaryen.i32, true);
-  module.addTagImport("a-tag-imp", "module", "base", binaryen.i32, binaryen.none);
+  var iF = binaryen.createType([binaryen.Type.i32, binaryen.Type.f64]);
+  module.addFunctionImport("an-imported", "module", "base", iF, binaryen.Type.f32);
+  module.addGlobalImport("a-global-imp", "module", "base", binaryen.Type.i32, false);
+  module.addGlobalImport("a-mut-global-imp", "module", "base", binaryen.Type.i32, true);
+  module.addTagImport("a-tag-imp", "module", "base", binaryen.Type.i32, binaryen.Type.none);
 
   // Exports
 
@@ -777,10 +777,10 @@ function test_core() {
   assert(module.getNumTables() === 1);
   assert(module.getNumElementSegments() === 1);
 
-  module.addTable("t2", 1, 1, binaryen.i31ref, module.ref.i31(module.i32.const(1)));
+  module.addTable("t2", 1, 1, binaryen.Type.i31ref, module.ref.i31(module.i32.const(1)));
 
   // Start function. One per module
-  var starter = module.addFunction("starter", binaryen.none, binaryen.none, [], module.nop());
+  var starter = module.addFunction("starter", binaryen.Type.none, binaryen.Type.none, [], module.nop());
   module.setStart(starter);
   assert(module.getStart() == starter);
 
@@ -804,15 +804,15 @@ function makeCallCheck(x) {
 
 function test_relooper() {
   module = new binaryen.Module();
-  var localTypes = [ binaryen.i32 ];
+  var localTypes = [ binaryen.Type.i32 ];
 
-  module.addFunctionImport("check", "module", "check", binaryen.i32, binaryen.none);
+  module.addFunctionImport("check", "module", "check", binaryen.Type.i32, binaryen.Type.none);
 
   { // trivial: just one block
     var relooper = new binaryen.Relooper(module);
     var block = relooper.addBlock(makeCallCheck(1337));
     var body = relooper.renderAndDispose(block, 0, module);
-    module.addFunction("just-one-block", binaryen.none, binaryen.none, localTypes, body);
+    module.addFunction("just-one-block", binaryen.Type.none, binaryen.Type.none, localTypes, body);
   }
   { // two blocks
     var relooper = new binaryen.Relooper(module);
@@ -820,7 +820,7 @@ function test_relooper() {
     var block1 = relooper.addBlock(makeCallCheck(1));
     relooper.addBranch(block0, block1); // no condition, no code on branch
     var body = relooper.renderAndDispose(block0, 0, module);
-    module.addFunction("two-blocks", binaryen.none, binaryen.none, localTypes, body);
+    module.addFunction("two-blocks", binaryen.Type.none, binaryen.Type.none, localTypes, body);
   }
   { // two blocks with code between them
     var relooper = new binaryen.Relooper(module);
@@ -828,7 +828,7 @@ function test_relooper() {
     var block1 = relooper.addBlock(makeCallCheck(1));
     relooper.addBranch(block0, block1, null, makeDroppedInt32(77)); // code on branch
     var body = relooper.renderAndDispose(block0, 0, module);
-    module.addFunction("two-blocks-plus-code", binaryen.none, binaryen.none, localTypes, body);
+    module.addFunction("two-blocks-plus-code", binaryen.Type.none, binaryen.Type.none, localTypes, body);
   }
   { // two blocks in a loop
     var relooper = new binaryen.Relooper(module);
@@ -837,7 +837,7 @@ function test_relooper() {
     relooper.addBranch(block0, block1, null, null);
     relooper.addBranch(block1, block0, null, null);
     var body = relooper.renderAndDispose(block0, 0, module);
-    module.addFunction("loop", binaryen.none, binaryen.none, localTypes, body);
+    module.addFunction("loop", binaryen.Type.none, binaryen.Type.none, localTypes, body);
   }
   { // two blocks in a loop with codes
     var relooper = new binaryen.Relooper(module);
@@ -846,7 +846,7 @@ function test_relooper() {
     relooper.addBranch(block0, block1, null, makeDroppedInt32(33));
     relooper.addBranch(block1, block0, null, makeDroppedInt32(-66));
     var body = relooper.renderAndDispose(block0, 0, module);
-    module.addFunction("loop-plus-code", binaryen.none, binaryen.none, localTypes, body);
+    module.addFunction("loop-plus-code", binaryen.Type.none, binaryen.Type.none, localTypes, body);
   }
   { // split
     var relooper = new binaryen.Relooper(module);
@@ -856,7 +856,7 @@ function test_relooper() {
     relooper.addBranch(block0, block1, makeInt32(55), null);
     relooper.addBranch(block0, block2, null, null);
     var body = relooper.renderAndDispose(block0, 0, module);
-    module.addFunction("split", binaryen.none, binaryen.none, localTypes, body);
+    module.addFunction("split", binaryen.Type.none, binaryen.Type.none, localTypes, body);
   }
   { // split + code
     var relooper = new binaryen.Relooper(module);
@@ -867,7 +867,7 @@ function test_relooper() {
     relooper.addBranch(block0, block1, makeInt32(55), temp);
     relooper.addBranch(block0, block2, null, makeDroppedInt32(20));
     var body = relooper.renderAndDispose(block0, 0, module);
-    module.addFunction("split-plus-code", binaryen.none, binaryen.none, localTypes, body);
+    module.addFunction("split-plus-code", binaryen.Type.none, binaryen.Type.none, localTypes, body);
   }
   { // if
     var relooper = new binaryen.Relooper(module);
@@ -878,7 +878,7 @@ function test_relooper() {
     relooper.addBranch(block0, block2, null, null);
     relooper.addBranch(block1, block2, null, null);
     var body = relooper.renderAndDispose(block0, 0, module);
-    module.addFunction("if", binaryen.none, binaryen.none, localTypes, body);
+    module.addFunction("if", binaryen.Type.none, binaryen.Type.none, localTypes, body);
   }
   { // if + code
     var relooper = new binaryen.Relooper(module);
@@ -890,7 +890,7 @@ function test_relooper() {
     relooper.addBranch(block0, block2, null, makeDroppedInt32(-2));
     relooper.addBranch(block1, block2, null, makeDroppedInt32(-3));
     var body = relooper.renderAndDispose(block0, 0, module);
-    module.addFunction("if-plus-code", binaryen.none, binaryen.none, localTypes, body);
+    module.addFunction("if-plus-code", binaryen.Type.none, binaryen.Type.none, localTypes, body);
   }
   { // if-else
     var relooper = new binaryen.Relooper(module);
@@ -903,7 +903,7 @@ function test_relooper() {
     relooper.addBranch(block1, block3, null, null);
     relooper.addBranch(block2, block3, null, null);
     var body = relooper.renderAndDispose(block0, 0, module);
-    module.addFunction("if-else", binaryen.none, binaryen.none, localTypes, body);
+    module.addFunction("if-else", binaryen.Type.none, binaryen.Type.none, localTypes, body);
   }
   { // loop+tail
     var relooper = new binaryen.Relooper(module);
@@ -914,7 +914,7 @@ function test_relooper() {
     relooper.addBranch(block1, block0, makeInt32(10), null);
     relooper.addBranch(block1, block2, null, null);
     var body = relooper.renderAndDispose(block0, 0, module);
-    module.addFunction("loop-tail", binaryen.none, binaryen.none, localTypes, body);
+    module.addFunction("loop-tail", binaryen.Type.none, binaryen.Type.none, localTypes, body);
   }
   { // nontrivial loop + phi to head
     var relooper = new binaryen.Relooper(module);
@@ -935,7 +935,7 @@ function test_relooper() {
     relooper.addBranch(block4, block5, null, null);
     relooper.addBranch(block5, block6, null, makeDroppedInt32(40));
     var body = relooper.renderAndDispose(block0, 0, module);
-    module.addFunction("nontrivial-loop-plus-phi-to-head", binaryen.none, binaryen.none, localTypes, body);
+    module.addFunction("nontrivial-loop-plus-phi-to-head", binaryen.Type.none, binaryen.Type.none, localTypes, body);
   }
   { // switch
     var relooper = new binaryen.Relooper(module);
@@ -948,7 +948,7 @@ function test_relooper() {
     relooper.addBranchForSwitch(block0, block2, [4], makeDroppedInt32(55));
     relooper.addBranchForSwitch(block0, block3, [], null);
     var body = relooper.renderAndDispose(block0, 0, module);
-    module.addFunction("switch", binaryen.none, binaryen.none, localTypes, body);
+    module.addFunction("switch", binaryen.Type.none, binaryen.Type.none, localTypes, body);
   }
   { // duff's device
     var relooper = new binaryen.Relooper(module);
@@ -960,7 +960,7 @@ function test_relooper() {
     relooper.addBranch(block1, block2, null, null);
     relooper.addBranch(block2, block1, null, null);
     var body = relooper.renderAndDispose(block0, 3, module); // use $3 as the helper var
-    module.addFunction("duffs-device", binaryen.none, binaryen.none, [ binaryen.i32, binaryen.i32, binaryen.i64, binaryen.i32, binaryen.f32, binaryen.f64, binaryen.i32 ], body);
+    module.addFunction("duffs-device", binaryen.Type.none, binaryen.Type.none, [ binaryen.Type.i32, binaryen.Type.i32, binaryen.Type.i64, binaryen.Type.i32, binaryen.Type.f32, binaryen.Type.f64, binaryen.Type.i32 ], body);
   }
 
   { // return in a block
@@ -968,7 +968,7 @@ function test_relooper() {
     var list = module.block("the-list", [ makeCallCheck(42), module.return(makeInt32(1337)) ]);
     var block = relooper.addBlock(list);
     var body = relooper.renderAndDispose(block, 0, module);
-    module.addFunction("return", binaryen.none, binaryen.i32, localTypes, body);
+    module.addFunction("return", binaryen.Type.none, binaryen.Type.i32, localTypes, body);
   }
 
   console.log("raw:");
@@ -996,14 +996,14 @@ function test_binaries() {
   { // create a module and write it to binary
     module = new binaryen.Module();
     module.setFeatures(binaryen.Features.All);
-    var ii = binaryen.createType([binaryen.i32, binaryen.i32]);
-    var x = module.local.get(0, binaryen.i32),
-        y = module.local.get(1, binaryen.i32);
+    var ii = binaryen.createType([binaryen.Type.i32, binaryen.Type.i32]);
+    var x = module.local.get(0, binaryen.Type.i32),
+        y = module.local.get(1, binaryen.Type.i32);
     var add = module.i32.add(x, y);
-    var adder = module.addFunction("adder", ii, binaryen.i32, [], add);
+    var adder = module.addFunction("adder", ii, binaryen.Type.i32, [], add);
     var initExpr = module.i32.const(3);
-    var global = module.addGlobal("a-global", binaryen.i32, false, initExpr)
-    var tag = module.addTag("a-tag", binaryen.createType([binaryen.i32, binaryen.i32]), binaryen.none);
+    var global = module.addGlobal("a-global", binaryen.Type.i32, false, initExpr)
+    var tag = module.addTag("a-tag", binaryen.createType([binaryen.Type.i32, binaryen.Type.i32]), binaryen.Type.none);
     binaryen.setDebugInfo(true); // include names section
     buffer = module.emitBinary();
     binaryen.setDebugInfo(false);
@@ -1028,8 +1028,8 @@ function test_binaries() {
 function test_binaries_with_features() {
   var builder = new binaryen.TypeBuilder(1);
   builder.setStructType(0, [
-    { type: binaryen.i32, packedType: binaryen.notPacked, mutable: true },
-    { type: binaryen.f64, packedType: binaryen.notPacked, mutable: true }
+    { type: binaryen.Type.i32, packedType: binaryen.PackedType.notPacked, mutable: true },
+    { type: binaryen.Type.f64, packedType: binaryen.PackedType.notPacked, mutable: true }
   ]);
   var [structHeapType] = builder.buildAndDispose();
   var structType = binaryen.getTypeFromHeapType(structHeapType, true);
@@ -1047,11 +1047,11 @@ function test_binaries_with_features() {
     )
   );
 
-  module.addFunction("get-field", binaryen.none, binaryen.i32, [],
+  module.addFunction("get-field", binaryen.Type.none, binaryen.Type.i32, [],
     module.struct.get(
       0,
       module.global.get("struct-global", structType),
-      binaryen.i32,
+      binaryen.Type.i32,
       false
     )
   );
@@ -1078,9 +1078,9 @@ function test_interpret() {
   // create a simple module with a start method that prints a number, and interpret it, printing that number.
   module = new binaryen.Module();
 
-  module.addFunctionImport("print-i32", "spectest", "print", binaryen.i32, binaryen.none);
+  module.addFunctionImport("print-i32", "spectest", "print", binaryen.Type.i32, binaryen.Type.none);
   var call = module.call("print-i32", [ makeInt32(1234) ], binaryen.None);
-  var starter = module.addFunction("starter", binaryen.none, binaryen.none, [], call);
+  var starter = module.addFunction("starter", binaryen.Type.none, binaryen.Type.none, [], call);
   module.setStart(starter);
 
   console.log(module.emitText());
@@ -1093,7 +1093,7 @@ function test_nonvalid() {
   // create a module that fails to validate
   module = new binaryen.Module();
 
-  var func = module.addFunction("func", binaryen.none, binaryen.none, [ binaryen.i32 ],
+  var func = module.addFunction("func", binaryen.Type.none, binaryen.Type.none, [ binaryen.Type.i32 ],
     module.local.set(0, makeInt64(1234, 0)) // wrong type!
   );
 
@@ -1110,14 +1110,14 @@ function test_parsing() {
   module = new binaryen.Module();
   module.setFeatures(binaryen.Features.All);
 
-  var ii = binaryen.createType([binaryen.i32, binaryen.i32]);
-  var x = module.local.get(0, binaryen.i32),
-      y = module.local.get(1, binaryen.i32);
+  var ii = binaryen.createType([binaryen.Type.i32, binaryen.Type.i32]);
+  var x = module.local.get(0, binaryen.Type.i32),
+      y = module.local.get(1, binaryen.Type.i32);
   var add = module.i32.add(x, y);
-  var adder = module.addFunction("adder", ii, binaryen.i32, [], add);
+  var adder = module.addFunction("adder", ii, binaryen.Type.i32, [], add);
   var initExpr = module.i32.const(3);
-  var global = module.addGlobal("a-global", binaryen.i32, false, initExpr)
-  var tag = module.addTag("a-tag", binaryen.i32, binaryen.none);
+  var global = module.addGlobal("a-global", binaryen.Type.i32, false, initExpr)
+  var tag = module.addTag("a-tag", binaryen.Type.i32, binaryen.Type.none);
   text = module.emitText();
   module.dispose();
   module = null;
@@ -1160,9 +1160,9 @@ function test_for_each() {
   var funcNames = [ "fn0", "fn1", "fn2" ];
 
   var fns = [
-    module.addFunction(funcNames[0], binaryen.none, binaryen.none, [], module.nop()),
-    module.addFunction(funcNames[1], binaryen.none, binaryen.none, [], module.nop()),
-    module.addFunction(funcNames[2], binaryen.none, binaryen.none, [], module.nop())
+    module.addFunction(funcNames[0], binaryen.Type.none, binaryen.Type.none, [], module.nop()),
+    module.addFunction(funcNames[1], binaryen.Type.none, binaryen.Type.none, [], module.nop()),
+    module.addFunction(funcNames[2], binaryen.Type.none, binaryen.Type.none, [], module.nop())
   ];
 
   var i;
@@ -1186,9 +1186,9 @@ function test_for_each() {
   var expected_passive = [false, false, true];
 
   var glos = [
-    module.addGlobal("a-global", binaryen.i32, false, module.i32.const(expected_offsets[1])),
-    module.addGlobal("a-global2", binaryen.i32, false, module.i32.const(2)),
-    module.addGlobal("a-global3", binaryen.i32, false, module.i32.const(3))
+    module.addGlobal("a-global", binaryen.Type.i32, false, module.i32.const(expected_offsets[1])),
+    module.addGlobal("a-global2", binaryen.Type.i32, false, module.i32.const(2)),
+    module.addGlobal("a-global3", binaryen.Type.i32, false, module.i32.const(3))
   ];
 
   for (i = 0; i < module.getNumGlobals(); i++) {
@@ -1296,9 +1296,9 @@ function test_relaxed_atomics() {
     module.drop(rmw),
     module.drop(cmpxchg),
     fence,
-  ], binaryen.auto);
+  ], binaryen.Type.auto);
 
-  module.addFunction("acquire-release-atomics", binaryen.none, binaryen.none, [], body);
+  module.addFunction("acquire-release-atomics", binaryen.Type.none, binaryen.Type.none, [], body);
 
   console.log(module.emitText());
   module.dispose();
diff --git a/test/binaryen.js/reloc.js b/test/binaryen.js/reloc.js
index cd63fb5a45d..1ea6d9764a2 100644
--- a/test/binaryen.js/reloc.js
+++ b/test/binaryen.js/reloc.js
@@ -2,21 +2,21 @@ var module = new binaryen.Module();
 
 // memory with offset
 
-module.addGlobalImport("memory_base", "env", "memory_base", binaryen.i32, false);
+module.addGlobalImport("memory_base", "env", "memory_base", binaryen.Type.i32, false);
 module.setMemory(1, -1, null, [
   {
     name: "x0",
-    offset: module.global.get("memory_base", binaryen.i32),
+    offset: module.global.get("memory_base", binaryen.Type.i32),
     data: "data data".split('').map(function(x) { return x.charCodeAt(0) })
   }
 ]);
 
 // table with offset
 
-var func = module.addFunction("func", binaryen.none, binaryen.none, [], module.nop());
+var func = module.addFunction("func", binaryen.Type.none, binaryen.Type.none, [], module.nop());
 
-module.addGlobalImport("table_base", "env", "table_base", binaryen.i32, false);
-module.addTable("0", 1, -1, binaryen.funcref);
-module.addActiveElementSegment("0", "0", [ "func", "func" ], module.global.get("table_base", binaryen.i32));
+module.addGlobalImport("table_base", "env", "table_base", binaryen.Type.i32, false);
+module.addTable("0", 1, -1, binaryen.Type.funcref);
+module.addActiveElementSegment("0", "0", [ "func", "func" ], module.global.get("table_base", binaryen.Type.i32));
 assert(module.validate());
 console.log(module.emitText());
diff --git a/test/binaryen.js/sideffects.js b/test/binaryen.js/sideffects.js
index a2ff4778a33..1b76ba98197 100644
--- a/test/binaryen.js/sideffects.js
+++ b/test/binaryen.js/sideffects.js
@@ -14,6 +14,7 @@ console.log("SideEffects.IsAtomic=" + binaryen.SideEffects.IsAtomic);
 console.log("SideEffects.Throws=" + binaryen.SideEffects.Throws);
 console.log("SideEffects.DanglingPop=" + binaryen.SideEffects.DanglingPop);
 console.log("SideEffects.TrapsNeverHappen=" + binaryen.SideEffects.TrapsNeverHappen);
+console.log("SideEffects.Suspends=" + binaryen.SideEffects.Suspends);
 console.log("SideEffects.Any=" + binaryen.SideEffects.Any);
 
 var module = new binaryen.Module();
@@ -36,7 +37,7 @@ assert(
 );
 assert(
   binaryen.getSideEffects(
-    module.call("test", [], binaryen.i32),
+    module.call("test", [], binaryen.Type.i32),
     module
   )
   ==
@@ -44,7 +45,7 @@ assert(
 );
 assert(
   binaryen.getSideEffects(
-    module.local.get("test", binaryen.i32),
+    module.local.get("test", binaryen.Type.i32),
     module
   )
   ==
@@ -62,11 +63,11 @@ assert(
 );
 
 // Add a global for the test, as computing side effects will look for it.
-module.addGlobal('test', binaryen.i32, true, module.i32.const(42));
+module.addGlobal('test', binaryen.Type.i32, true, module.i32.const(42));
 
 assert(
   binaryen.getSideEffects(
-    module.global.get("test", binaryen.i32),
+    module.global.get("test", binaryen.Type.i32),
     module
   )
   ==
@@ -114,16 +115,38 @@ assert(
 );
 
 // If exception handling feature is enabled, calls can throw
-module.setFeatures(binaryen.Features.All);
+module.setFeatures(binaryen.Features.ExceptionHandling);
 assert(
   binaryen.getSideEffects(
-    module.call("test", [], binaryen.i32),
+    module.call("test", [], binaryen.Type.i32),
     module
   )
   ==
   (binaryen.SideEffects.Calls | binaryen.SideEffects.Throws)
 );
 
+// If stack switching feature is enabled, calls can suspend
+module.setFeatures(binaryen.Features.StackSwitching);
+assert(
+  binaryen.getSideEffects(
+    module.call("test", [], binaryen.Type.i32),
+    module
+  )
+  ==
+  (binaryen.SideEffects.Calls | binaryen.SideEffects.Suspends)
+);
+
+// If all features are enabled, calls can throw and suspend
+module.setFeatures(binaryen.Features.All);
+assert(
+  binaryen.getSideEffects(
+    module.call("test", [], binaryen.Type.i32),
+    module
+  )
+  ==
+  (binaryen.SideEffects.Calls | binaryen.SideEffects.Throws | binaryen.SideEffects.Suspends)
+);
+
 assert(
   binaryen.getSideEffects(
     module.drop(module.i32.pop()),
diff --git a/test/binaryen.js/sideffects.js.txt b/test/binaryen.js/sideffects.js.txt
index b582d70bdc0..85fc6bb6b80 100644
--- a/test/binaryen.js/sideffects.js.txt
+++ b/test/binaryen.js/sideffects.js.txt
@@ -14,4 +14,5 @@ SideEffects.IsAtomic=2048
 SideEffects.Throws=4096
 SideEffects.DanglingPop=8192
 SideEffects.TrapsNeverHappen=16384
-SideEffects.Any=32767
+SideEffects.Suspends=32768
+SideEffects.Any=65535
diff --git a/test/binaryen.js/sieve.js b/test/binaryen.js/sieve.js
index 4ba61a43492..a315038b700 100644
--- a/test/binaryen.js/sieve.js
+++ b/test/binaryen.js/sieve.js
@@ -14,14 +14,14 @@ var body = module.block(
           module.memory.size(),
           module.i32.const(65536)
         ),
-        module.local.get(0, binaryen.i32)
+        module.local.get(0, binaryen.Type.i32)
       ),
       module.drop(
         module.memory.grow(
           module.i32.sub(
             module.i32.div_u(
               module.i32.add(
-                module.local.get(0, binaryen.i32),
+                module.local.get(0, binaryen.Type.i32),
                 module.i32.const(65535)
               ),
               module.i32.const(65536)
@@ -35,28 +35,28 @@ var body = module.block(
     module.local.set(1, module.i32.const(0)),
     module.loop('clear', module.block(null, [
       module.i32.store8(0, 1,
-        module.local.get(1, binaryen.i32),
+        module.local.get(1, binaryen.Type.i32),
         module.i32.const(0)
       ),
       module.local.set(1, module.i32.add(
-        module.local.get(1, binaryen.i32),
+        module.local.get(1, binaryen.Type.i32),
         module.i32.const(1)
       )),
       module.br_if('clear', module.i32.eq(
-        module.local.get(1, binaryen.i32),
-        module.local.get(0, binaryen.i32)
+        module.local.get(1, binaryen.Type.i32),
+        module.local.get(0, binaryen.Type.i32)
       ))
     ])),
     // perform the sieve TODO
     // calculate how many primes there are
-    module.return(module.local.get(0, binaryen.i32))
+    module.return(module.local.get(0, binaryen.Type.i32))
   ],
-  binaryen.none
+  binaryen.Type.none
 );
 
 // Create the add function
 // Note: no additional local variables (that's the [])
-module.addFunction('sieve', binaryen.i32, binaryen.i32, [binaryen.i32], body);
+module.addFunction('sieve', binaryen.Type.i32, binaryen.Type.i32, [binaryen.Type.i32], body);
 
 // Export the function, so we can call it later (for simplicity we
 // export it as the same name as it has internally)
diff --git a/test/binaryen.js/sourcemap.js b/test/binaryen.js/sourcemap.js
index 90f41c72099..a3e5e57b9e3 100644
--- a/test/binaryen.js/sourcemap.js
+++ b/test/binaryen.js/sourcemap.js
@@ -8,9 +8,9 @@ console.log();
 var expr = module.i32.const(1);
 var body = module.block("", [
   expr
-], binaryen.i32);
+], binaryen.Type.i32);
 
-var func = module.addFunction("main", binaryen.none, binaryen.i32, [], body);
+var func = module.addFunction("main", binaryen.Type.none, binaryen.Type.i32, [], body);
 
 module.setDebugLocation(func, expr, fileIndex, 1, 2);
 module.setDebugLocation(func, body, fileIndex, 0, 3);
diff --git a/test/binaryen.js/tables.js b/test/binaryen.js/tables.js
index f711d0d054c..b3834818a25 100644
--- a/test/binaryen.js/tables.js
+++ b/test/binaryen.js/tables.js
@@ -34,16 +34,16 @@ assert(binaryen.Table.getMax(tablePtr) === 20);
 binaryen.Table.setMax(tablePtr, tableMax);
 
 // get/set type
-assert(binaryen.Table.getType(tablePtr) === binaryen.funcref);
-binaryen.Table.setType(tablePtr, binaryen.anyref);
-assert(binaryen.Table.getType(tablePtr) === binaryen.anyref);
-binaryen.Table.setType(tablePtr, binaryen.funcref);
+assert(binaryen.Table.getType(tablePtr) === binaryen.Type.funcref);
+binaryen.Table.setType(tablePtr, binaryen.Type.anyref);
+assert(binaryen.Table.getType(tablePtr) === binaryen.Type.anyref);
+binaryen.Table.setType(tablePtr, binaryen.Type.funcref);
 
 const tableRef = binaryen.Table(tablePtr);
 assert(tableRef.name === tableName);
 assert(tableRef.initial === tableMin);
 assert(tableRef.max === tableMax);
-assert(tableRef.type === binaryen.funcref);
+assert(tableRef.type === binaryen.Type.funcref);
 
 // Cleanup
 assert(module.validate());
diff --git a/test/binaryen.js/tag.js b/test/binaryen.js/tag.js
index 88783fe5511..833ed2a022f 100644
--- a/test/binaryen.js/tag.js
+++ b/test/binaryen.js/tag.js
@@ -11,9 +11,9 @@ module.setFeatures(binaryen.Features.ReferenceTypes |
                    binaryen.Features.ExceptionHandling |
                    binaryen.Features.Multivalue);
 
-var pairType = binaryen.createType([binaryen.i32, binaryen.f32]);
+var pairType = binaryen.createType([binaryen.Type.i32, binaryen.Type.f32]);
 
-var tag = module.addTag("a-tag", binaryen.i32, binaryen.none);
+var tag = module.addTag("a-tag", binaryen.Type.i32, binaryen.Type.none);
 
 console.log("GetTag is equal: " + (tag === module.getTag("a-tag")));
 
@@ -21,7 +21,7 @@ var tagInfo = binaryen.getTagInfo(tag);
 console.log("getTagInfo=" + JSON.stringify(cleanInfo(tagInfo)));
 
 module.addTagExport("a-tag", "a-tag-exp");
-module.addTagImport("a-tag-imp", "module", "base", pairType, binaryen.none);
+module.addTagImport("a-tag-imp", "module", "base", pairType, binaryen.Type.none);
 
 assert(module.validate());
 console.log(module.emitText());
diff --git a/test/binaryen.js/tail_calls.js b/test/binaryen.js/tail_calls.js
index 61fe5d829fb..2bde4834b2e 100644
--- a/test/binaryen.js/tail_calls.js
+++ b/test/binaryen.js/tail_calls.js
@@ -6,23 +6,23 @@ module.addTableImport("0", "env", "table");
 
 var foo = module.addFunction(
   "foo",
-  binaryen.none,
-  binaryen.none,
+  binaryen.Type.none,
+  binaryen.Type.none,
   [],
-  module.return_call("foo", [], binaryen.none, binaryen.none)
+  module.return_call("foo", [], binaryen.Type.none, binaryen.Type.none)
 );
 
 var bar = module.addFunction(
   "bar",
-  binaryen.none,
-  binaryen.none,
+  binaryen.Type.none,
+  binaryen.Type.none,
   [],
   module.return_call_indirect(
     "0",
     module.i32.const(0),
     [],
-    binaryen.none,
-    binaryen.none
+    binaryen.Type.none,
+    binaryen.Type.none
   )
 );
 
diff --git a/test/binaryen.js/validation_errors.js b/test/binaryen.js/validation_errors.js
index b7ee5d00ea8..b22112f589b 100644
--- a/test/binaryen.js/validation_errors.js
+++ b/test/binaryen.js/validation_errors.js
@@ -1,9 +1,9 @@
 (function() {
   var mod = new binaryen.Module();
-  var func = mod.addFunction("test", binaryen.none, binaryen.none, [],
+  var func = mod.addFunction("test", binaryen.Type.none, binaryen.Type.none, [],
     mod.block("", [
       mod.drop(
-        mod.global.get("missing", binaryen.i32)
+        mod.global.get("missing", binaryen.Type.i32)
       )
     ])
   );
@@ -13,10 +13,10 @@
 
 (function() {
   var mod = new binaryen.Module();
-  var func = mod.addFunction("test", binaryen.none, binaryen.none, [],
+  var func = mod.addFunction("test", binaryen.Type.none, binaryen.Type.none, [],
     mod.block("", [
       mod.drop(
-        mod.local.get(0, binaryen.i32)
+        mod.local.get(0, binaryen.Type.i32)
       )
     ])
   );
diff --git a/test/gtest/CMakeLists.txt b/test/gtest/CMakeLists.txt
index c48edef2dd7..b0a73d21d1e 100644
--- a/test/gtest/CMakeLists.txt
+++ b/test/gtest/CMakeLists.txt
@@ -15,6 +15,7 @@ set(unittest_SOURCES
   delta_debugging.cpp
   dfa_minimization.cpp
   disjoint_sets.cpp
+  effects.cpp
   graph.cpp
   int128.cpp
   leaves.cpp
@@ -31,6 +32,7 @@ set(unittest_SOURCES
   printing.cpp
   public-type-validator.cpp
   scc.cpp
+  sizes.cpp
   span.cpp
   stringify.cpp
   subtype-exprs.cpp
diff --git a/test/gtest/constraint.cpp b/test/gtest/constraint.cpp
index 5c00d18f047..720aafcfdad 100644
--- a/test/gtest/constraint.cpp
+++ b/test/gtest/constraint.cpp
@@ -1,7 +1,8 @@
 #include <limits>
 
-#include "ir/constraint.h"
 #include "ir/abstract.h"
+#include "ir/constraint.h"
+#include "wasm-builder.h"
 #include "gtest/gtest.h"
 
 using namespace wasm;
@@ -1408,3 +1409,645 @@ TEST(ConstraintTest, FloatNegativeZero) {
   EXPECT_EQ(s32.proves(Constraint{Eq, {Literal(float(-0.0f))}}), True);
   EXPECT_EQ(s32.proves(Constraint{Ne, {Literal(float(-0.0f))}}), False);
 }
+
+TEST(ConstraintTest, EqualTermPairs) {
+  // Constraints with the term equal to local $1.
+  Constraint eq1{Eq, {Index(1)}};
+  Constraint ne1{Ne, {Index(1)}};
+  Constraint ltS1{LtS, {Index(1)}};
+  Constraint leS1{LeS, {Index(1)}};
+  Constraint gtS1{GtS, {Index(1)}};
+  Constraint geS1{GeS, {Index(1)}};
+  Constraint ltU1{LtU, {Index(1)}};
+  Constraint leU1{LeU, {Index(1)}};
+  Constraint gtU1{GtU, {Index(1)}};
+  Constraint geU1{GeU, {Index(1)}};
+
+  // Constraints with a different term, local $2.
+  Constraint eq2{Eq, {Index(2)}};
+  Constraint ne2{Ne, {Index(2)}};
+  Constraint ltS2{LtS, {Index(2)}};
+  Constraint leS2{LeS, {Index(2)}};
+  Constraint gtS2{GtS, {Index(2)}};
+  Constraint geS2{GeS, {Index(2)}};
+  Constraint ltU2{LtU, {Index(2)}};
+  Constraint leU2{LeU, {Index(2)}};
+  Constraint gtU2{GtU, {Index(2)}};
+  Constraint geU2{GeU, {Index(2)}};
+
+  // 1. Eq (x == $1):
+  // == proves <= and >= (both signed and unsigned) are True.
+  EXPECT_EQ(AndedConstraintSet{eq1}.proves(leS1), True);
+  EXPECT_EQ(AndedConstraintSet{eq1}.proves(leU1), True);
+  EXPECT_EQ(AndedConstraintSet{eq1}.proves(geS1), True);
+  EXPECT_EQ(AndedConstraintSet{eq1}.proves(geU1), True);
+
+  // == proves < and > (both signed and unsigned) are False.
+  EXPECT_EQ(AndedConstraintSet{eq1}.proves(ltS1), False);
+  EXPECT_EQ(AndedConstraintSet{eq1}.proves(ltU1), False);
+  EXPECT_EQ(AndedConstraintSet{eq1}.proves(gtS1), False);
+  EXPECT_EQ(AndedConstraintSet{eq1}.proves(gtU1), False);
+
+  // == proves == is True, and != is False.
+  EXPECT_EQ(AndedConstraintSet{eq1}.proves(eq1), True);
+  EXPECT_EQ(AndedConstraintSet{eq1}.proves(ne1), False);
+
+  // 2. LtS (x <_s $1):
+  // < proves <= and != are True.
+  EXPECT_EQ(AndedConstraintSet{ltS1}.proves(leS1), True);
+  EXPECT_EQ(AndedConstraintSet{ltS1}.proves(ne1), True);
+  // < proves ==, >, and >= are False.
+  EXPECT_EQ(AndedConstraintSet{ltS1}.proves(eq1), False);
+  EXPECT_EQ(AndedConstraintSet{ltS1}.proves(gtS1), False);
+  EXPECT_EQ(AndedConstraintSet{ltS1}.proves(geS1), False);
+  // Self
+  EXPECT_EQ(AndedConstraintSet{ltS1}.proves(ltS1), True);
+  // Cross-signedness are Unknown.
+  EXPECT_EQ(AndedConstraintSet{ltS1}.proves(ltU1), Unknown);
+  EXPECT_EQ(AndedConstraintSet{ltS1}.proves(leU1), Unknown);
+  EXPECT_EQ(AndedConstraintSet{ltS1}.proves(gtU1), Unknown);
+  EXPECT_EQ(AndedConstraintSet{ltS1}.proves(geU1), Unknown);
+
+  // 3. LeS (x <=_s $1):
+  // <= proves > is False.
+  EXPECT_EQ(AndedConstraintSet{leS1}.proves(gtS1), False);
+  // Self
+  EXPECT_EQ(AndedConstraintSet{leS1}.proves(leS1), True);
+  // Others are Unknown.
+  EXPECT_EQ(AndedConstraintSet{leS1}.proves(ltS1), Unknown);
+  EXPECT_EQ(AndedConstraintSet{leS1}.proves(geS1), Unknown);
+  EXPECT_EQ(AndedConstraintSet{leS1}.proves(eq1), Unknown);
+  EXPECT_EQ(AndedConstraintSet{leS1}.proves(ne1), Unknown);
+  EXPECT_EQ(AndedConstraintSet{leS1}.proves(ltU1), Unknown);
+  EXPECT_EQ(AndedConstraintSet{leS1}.proves(leU1), Unknown);
+  EXPECT_EQ(AndedConstraintSet{leS1}.proves(gtU1), Unknown);
+  EXPECT_EQ(AndedConstraintSet{leS1}.proves(geU1), Unknown);
+
+  // 4. GtS (x >_s $1):
+  // > proves >= and != are True.
+  EXPECT_EQ(AndedConstraintSet{gtS1}.proves(geS1), True);
+  EXPECT_EQ(AndedConstraintSet{gtS1}.proves(ne1), True);
+  // > proves ==, <, and <= are False.
+  EXPECT_EQ(AndedConstraintSet{gtS1}.proves(eq1), False);
+  EXPECT_EQ(AndedConstraintSet{gtS1}.proves(ltS1), False);
+  EXPECT_EQ(AndedConstraintSet{gtS1}.proves(leS1), False);
+  // Self
+  EXPECT_EQ(AndedConstraintSet{gtS1}.proves(gtS1), True);
+  // Cross-signedness are Unknown.
+  EXPECT_EQ(AndedConstraintSet{gtS1}.proves(ltU1), Unknown);
+  EXPECT_EQ(AndedConstraintSet{gtS1}.proves(leU1), Unknown);
+  EXPECT_EQ(AndedConstraintSet{gtS1}.proves(gtU1), Unknown);
+  EXPECT_EQ(AndedConstraintSet{gtS1}.proves(geU1), Unknown);
+
+  // 5. GeS (x >=_s $1):
+  // >= proves < is False.
+  EXPECT_EQ(AndedConstraintSet{geS1}.proves(ltS1), False);
+  // Self
+  EXPECT_EQ(AndedConstraintSet{geS1}.proves(geS1), True);
+  // Others are Unknown.
+  EXPECT_EQ(AndedConstraintSet{geS1}.proves(gtS1), Unknown);
+  EXPECT_EQ(AndedConstraintSet{geS1}.proves(leS1), Unknown);
+  EXPECT_EQ(AndedConstraintSet{geS1}.proves(eq1), Unknown);
+  EXPECT_EQ(AndedConstraintSet{geS1}.proves(ne1), Unknown);
+  EXPECT_EQ(AndedConstraintSet{geS1}.proves(ltU1), Unknown);
+  EXPECT_EQ(AndedConstraintSet{geS1}.proves(leU1), Unknown);
+  EXPECT_EQ(AndedConstraintSet{geS1}.proves(gtU1), Unknown);
+  EXPECT_EQ(AndedConstraintSet{geS1}.proves(geU1), Unknown);
+
+  // 6. LtU (x <_u $1):
+  // < proves <= and != are True.
+  EXPECT_EQ(AndedConstraintSet{ltU1}.proves(leU1), True);
+  EXPECT_EQ(AndedConstraintSet{ltU1}.proves(ne1), True);
+  // < proves ==, >, and >= are False.
+  EXPECT_EQ(AndedConstraintSet{ltU1}.proves(eq1), False);
+  EXPECT_EQ(AndedConstraintSet{ltU1}.proves(gtU1), False);
+  EXPECT_EQ(AndedConstraintSet{ltU1}.proves(geU1), False);
+  // Self
+  EXPECT_EQ(AndedConstraintSet{ltU1}.proves(ltU1), True);
+  // Cross-signedness are Unknown.
+  EXPECT_EQ(AndedConstraintSet{ltU1}.proves(ltS1), Unknown);
+  EXPECT_EQ(AndedConstraintSet{ltU1}.proves(leS1), Unknown);
+  EXPECT_EQ(AndedConstraintSet{ltU1}.proves(gtS1), Unknown);
+  EXPECT_EQ(AndedConstraintSet{ltU1}.proves(geS1), Unknown);
+
+  // 7. LeU (x <=_u $1):
+  // <= proves > is False.
+  EXPECT_EQ(AndedConstraintSet{leU1}.proves(gtU1), False);
+  // Self
+  EXPECT_EQ(AndedConstraintSet{leU1}.proves(leU1), True);
+  // Others are Unknown.
+  EXPECT_EQ(AndedConstraintSet{leU1}.proves(ltU1), Unknown);
+  EXPECT_EQ(AndedConstraintSet{leU1}.proves(geU1), Unknown);
+  EXPECT_EQ(AndedConstraintSet{leU1}.proves(eq1), Unknown);
+  EXPECT_EQ(AndedConstraintSet{leU1}.proves(ne1), Unknown);
+  EXPECT_EQ(AndedConstraintSet{leU1}.proves(ltS1), Unknown);
+  EXPECT_EQ(AndedConstraintSet{leU1}.proves(leS1), Unknown);
+  EXPECT_EQ(AndedConstraintSet{leU1}.proves(gtS1), Unknown);
+  EXPECT_EQ(AndedConstraintSet{leU1}.proves(geS1), Unknown);
+
+  // 8. GtU (x >_u $1):
+  // > proves >= and != are True.
+  EXPECT_EQ(AndedConstraintSet{gtU1}.proves(geU1), True);
+  EXPECT_EQ(AndedConstraintSet{gtU1}.proves(ne1), True);
+  // > proves ==, <, and <= are False.
+  EXPECT_EQ(AndedConstraintSet{gtU1}.proves(eq1), False);
+  EXPECT_EQ(AndedConstraintSet{gtU1}.proves(ltU1), False);
+  EXPECT_EQ(AndedConstraintSet{gtU1}.proves(leU1), False);
+  // Self
+  EXPECT_EQ(AndedConstraintSet{gtU1}.proves(gtU1), True);
+  // Cross-signedness are Unknown.
+  EXPECT_EQ(AndedConstraintSet{gtU1}.proves(ltS1), Unknown);
+  EXPECT_EQ(AndedConstraintSet{gtU1}.proves(leS1), Unknown);
+  EXPECT_EQ(AndedConstraintSet{gtU1}.proves(gtS1), Unknown);
+  EXPECT_EQ(AndedConstraintSet{gtU1}.proves(geS1), Unknown);
+
+  // 9. GeU (x >=_u $1):
+  // >= proves < is False.
+  EXPECT_EQ(AndedConstraintSet{geU1}.proves(ltU1), False);
+  // Self
+  EXPECT_EQ(AndedConstraintSet{geU1}.proves(geU1), True);
+  // Others are Unknown.
+  EXPECT_EQ(AndedConstraintSet{geU1}.proves(gtU1), Unknown);
+  EXPECT_EQ(AndedConstraintSet{geU1}.proves(leU1), Unknown);
+  EXPECT_EQ(AndedConstraintSet{geU1}.proves(eq1), Unknown);
+  EXPECT_EQ(AndedConstraintSet{geU1}.proves(ne1), Unknown);
+  EXPECT_EQ(AndedConstraintSet{geU1}.proves(ltS1), Unknown);
+  EXPECT_EQ(AndedConstraintSet{geU1}.proves(leS1), Unknown);
+  EXPECT_EQ(AndedConstraintSet{geU1}.proves(gtS1), Unknown);
+  EXPECT_EQ(AndedConstraintSet{geU1}.proves(geS1), Unknown);
+
+  // 10. Ne (x != $1):
+  EXPECT_EQ(AndedConstraintSet{ne1}.proves(ne1), True);
+  EXPECT_EQ(AndedConstraintSet{ne1}.proves(eq1), False);
+  EXPECT_EQ(AndedConstraintSet{ne1}.proves(ltS1), Unknown);
+  EXPECT_EQ(AndedConstraintSet{ne1}.proves(leS1), Unknown);
+  EXPECT_EQ(AndedConstraintSet{ne1}.proves(gtS1), Unknown);
+  EXPECT_EQ(AndedConstraintSet{ne1}.proves(geS1), Unknown);
+  EXPECT_EQ(AndedConstraintSet{ne1}.proves(ltU1), Unknown);
+  EXPECT_EQ(AndedConstraintSet{ne1}.proves(leU1), Unknown);
+  EXPECT_EQ(AndedConstraintSet{ne1}.proves(gtU1), Unknown);
+  EXPECT_EQ(AndedConstraintSet{ne1}.proves(geU1), Unknown);
+
+  // 11. Different terms ($1 != $2) cannot prove one another.
+  EXPECT_EQ(AndedConstraintSet{eq1}.proves(eq2), Unknown);
+  EXPECT_EQ(AndedConstraintSet{eq1}.proves(leS2), Unknown);
+  EXPECT_EQ(AndedConstraintSet{eq1}.proves(ltS2), Unknown);
+  EXPECT_EQ(AndedConstraintSet{ltS1}.proves(leS2), Unknown);
+  EXPECT_EQ(AndedConstraintSet{gtS1}.proves(geS2), Unknown);
+  EXPECT_EQ(AndedConstraintSet{ltU1}.proves(leU2), Unknown);
+  EXPECT_EQ(AndedConstraintSet{gtU1}.proves(geU2), Unknown);
+
+  // 12. ANDing equal-term constraints:
+  // Redundant constraints are ignored.
+  AndedConstraintSet sEq{eq1};
+  sEq.approximateAnd(leS1);
+  EXPECT_EQ(sEq.size(), 1);
+  EXPECT_EQ(sEq[0], eq1);
+
+  AndedConstraintSet sLtS{ltS1};
+  sLtS.approximateAnd(ne1);
+  EXPECT_EQ(sLtS.size(), 1);
+  EXPECT_EQ(sLtS[0], ltS1);
+
+  AndedConstraintSet sGtS{gtS1};
+  sGtS.approximateAnd(ne1);
+  EXPECT_EQ(sGtS.size(), 1);
+  EXPECT_EQ(sGtS[0], gtS1);
+
+  AndedConstraintSet sLtU{ltU1};
+  sLtU.approximateAnd(ne1);
+  EXPECT_EQ(sLtU.size(), 1);
+  EXPECT_EQ(sLtU[0], ltU1);
+
+  AndedConstraintSet sGtU{gtU1};
+  sGtU.approximateAnd(ne1);
+  EXPECT_EQ(sGtU.size(), 1);
+  EXPECT_EQ(sGtU[0], gtU1);
+
+  // Contradicting constraints turn the set into a contradiction.
+  AndedConstraintSet sEqContra{eq1};
+  sEqContra.approximateAnd(ltS1);
+  EXPECT_TRUE(sEqContra.provesEverything());
+
+  AndedConstraintSet sLtSContra{ltS1};
+  sLtSContra.approximateAnd(eq1);
+  EXPECT_TRUE(sLtSContra.provesEverything());
+
+  AndedConstraintSet sGtSContra{gtS1};
+  sGtSContra.approximateAnd(eq1);
+  EXPECT_TRUE(sGtSContra.provesEverything());
+
+  AndedConstraintSet sLtUContra{ltU1};
+  sLtUContra.approximateAnd(eq1);
+  EXPECT_TRUE(sLtUContra.provesEverything());
+
+  AndedConstraintSet sGtUContra{gtU1};
+  sGtUContra.approximateAnd(eq1);
+  EXPECT_TRUE(sGtUContra.provesEverything());
+}
+
+TEST(ConstraintTest, ParseUnaryEqZ) {
+  Module wasm;
+  Builder builder(wasm);
+
+  // 1. Single i32.eqz of a local.get: parsed as x == 0.
+  {
+    auto* expr =
+      builder.makeUnary(EqZInt32, builder.makeLocalGet(0, Type::i32));
+    auto parsed = ParsedAndedConstraints::parse(expr);
+    EXPECT_FALSE(parsed.hasUnknown);
+    ASSERT_EQ(parsed.size(), 1);
+    EXPECT_EQ(parsed[0],
+              (LocalConstraint{0, Constraint{Eq, {Literal(int32_t(0))}}}));
+  }
+
+  // 2. Single i64.eqz of a local.get: parsed as x == 0_i64.
+  {
+    auto* expr =
+      builder.makeUnary(EqZInt64, builder.makeLocalGet(1, Type::i64));
+    auto parsed = ParsedAndedConstraints::parse(expr);
+    EXPECT_FALSE(parsed.hasUnknown);
+    ASSERT_EQ(parsed.size(), 1);
+    EXPECT_EQ(parsed[0],
+              (LocalConstraint{1, Constraint{Eq, {Literal(int64_t(0))}}}));
+  }
+
+  // 3. Nested eqz of eqz: parsed as x != 0.
+  {
+    auto* inner =
+      builder.makeUnary(EqZInt32, builder.makeLocalGet(0, Type::i32));
+    auto* expr = builder.makeUnary(EqZInt32, inner);
+    auto parsed = ParsedAndedConstraints::parse(expr);
+    EXPECT_FALSE(parsed.hasUnknown);
+    ASSERT_EQ(parsed.size(), 1);
+    EXPECT_EQ(parsed[0],
+              (LocalConstraint{0, Constraint{Ne, {Literal(int32_t(0))}}}));
+  }
+
+  // 4. Nested eqz of eqz with 64-bit inner: parsed as x != 0_i64.
+  {
+    auto* inner =
+      builder.makeUnary(EqZInt64, builder.makeLocalGet(1, Type::i64));
+    auto* expr = builder.makeUnary(EqZInt32, inner);
+    auto parsed = ParsedAndedConstraints::parse(expr);
+    EXPECT_FALSE(parsed.hasUnknown);
+    ASSERT_EQ(parsed.size(), 1);
+    EXPECT_EQ(parsed[0],
+              (LocalConstraint{1, Constraint{Ne, {Literal(int64_t(0))}}}));
+  }
+
+  // 5. eqz of non-local.get (e.g. call): unhandled, sets hasUnknown.
+  {
+    auto* call = builder.makeCall("foo", {}, Type::i32);
+    auto* expr = builder.makeUnary(EqZInt32, call);
+    auto parsed = ParsedAndedConstraints::parse(expr);
+    EXPECT_TRUE(parsed.empty());
+    EXPECT_TRUE(parsed.hasUnknown);
+  }
+
+  // 6. Double eqz where inner value is not a local.get: sets hasUnknown.
+  {
+    auto* call = builder.makeCall("foo", {}, Type::i32);
+    auto* inner = builder.makeUnary(EqZInt32, call);
+    auto* expr = builder.makeUnary(EqZInt32, inner);
+    auto parsed = ParsedAndedConstraints::parse(expr);
+    EXPECT_TRUE(parsed.empty());
+    EXPECT_TRUE(parsed.hasUnknown);
+  }
+
+  // 7. Unary operation that is not EqZ: sets hasUnknown.
+  {
+    auto* expr =
+      builder.makeUnary(ClzInt32, builder.makeLocalGet(0, Type::i32));
+    auto parsed = ParsedAndedConstraints::parse(expr);
+    EXPECT_TRUE(parsed.empty());
+    EXPECT_TRUE(parsed.hasUnknown);
+  }
+}
+
+TEST(ConstraintTest, ParseRefIsNull) {
+  Module wasm;
+  Builder builder(wasm);
+  auto anyref = Type(HeapType::any, Nullable);
+
+  // 1. ref.is_null of local.get: parsed as x == null.
+  {
+    auto* expr = builder.makeRefIsNull(builder.makeLocalGet(0, anyref));
+    auto parsed = ParsedAndedConstraints::parse(expr);
+    EXPECT_FALSE(parsed.hasUnknown);
+    ASSERT_EQ(parsed.size(), 1);
+    EXPECT_EQ(
+      parsed[0],
+      (LocalConstraint{0, Constraint{Eq, {Literal::makeNull(HeapType::any)}}}));
+  }
+
+  // 2. ref.is_null of non-local.get (e.g. call): unhandled, sets hasUnknown.
+  {
+    auto* call = builder.makeCall("foo", {}, anyref);
+    auto* expr = builder.makeRefIsNull(call);
+    auto parsed = ParsedAndedConstraints::parse(expr);
+    EXPECT_TRUE(parsed.empty());
+    EXPECT_TRUE(parsed.hasUnknown);
+  }
+
+  // 3. ref.is_null of constant: unhandled, sets hasUnknown.
+  {
+    auto* expr = builder.makeRefIsNull(builder.makeRefNull(HeapType::any));
+    auto parsed = ParsedAndedConstraints::parse(expr);
+    EXPECT_TRUE(parsed.empty());
+    EXPECT_TRUE(parsed.hasUnknown);
+  }
+}
+
+TEST(ConstraintTest, ParseBinary) {
+  Module wasm;
+  Builder builder(wasm);
+
+  // 1. Binary comparison with constant on right: parsed as local constraint.
+  {
+    auto* expr = builder.makeBinary(EqInt32,
+                                    builder.makeLocalGet(0, Type::i32),
+                                    builder.makeConst(Literal(int32_t(42))));
+    auto parsed = ParsedAndedConstraints::parse(expr);
+    EXPECT_FALSE(parsed.hasUnknown);
+    ASSERT_EQ(parsed.size(), 1);
+    EXPECT_EQ(parsed[0],
+              (LocalConstraint{0, Constraint{Eq, {Literal(int32_t(42))}}}));
+  }
+
+  // 2. Binary comparison with local.get on right: parsed as local constraint
+  {
+    auto* expr = builder.makeBinary(NeInt32,
+                                    builder.makeLocalGet(0, Type::i32),
+                                    builder.makeLocalGet(1, Type::i32));
+    auto parsed = ParsedAndedConstraints::parse(expr);
+    EXPECT_FALSE(parsed.hasUnknown);
+    ASSERT_EQ(parsed.size(), 1);
+    EXPECT_EQ(parsed[0], (LocalConstraint{0, Constraint{Ne, {Index(1)}}}));
+  }
+
+  // 3. All relational binary operators:
+  for (auto [wasmOp, abstractOp] : {
+         std::pair{EqInt32, Eq},
+         std::pair{NeInt32, Ne},
+         std::pair{LtSInt32, LtS},
+         std::pair{LtUInt32, LtU},
+         std::pair{LeSInt32, LeS},
+         std::pair{LeUInt32, LeU},
+         std::pair{GtSInt32, GtS},
+         std::pair{GtUInt32, GtU},
+         std::pair{GeSInt32, GeS},
+         std::pair{GeUInt32, GeU},
+       }) {
+    auto* expr = builder.makeBinary(wasmOp,
+                                    builder.makeLocalGet(0, Type::i32),
+                                    builder.makeConst(Literal(int32_t(5))));
+    auto parsed = ParsedAndedConstraints::parse(expr);
+    EXPECT_FALSE(parsed.hasUnknown);
+    ASSERT_EQ(parsed.size(), 1);
+    EXPECT_EQ(
+      parsed[0],
+      (LocalConstraint{0, Constraint{abstractOp, {Literal(int32_t(5))}}}));
+  }
+
+  // 64-bit comparison:
+  {
+    auto* expr = builder.makeBinary(LtSInt64,
+                                    builder.makeLocalGet(0, Type::i64),
+                                    builder.makeConst(Literal(int64_t(100))));
+    auto parsed = ParsedAndedConstraints::parse(expr);
+    EXPECT_FALSE(parsed.hasUnknown);
+    ASSERT_EQ(parsed.size(), 1);
+    EXPECT_EQ(parsed[0],
+              (LocalConstraint{0, Constraint{LtS, {Literal(int64_t(100))}}}));
+  }
+
+  // 4. Comparison where right is not a term (e.g. call): unhandled, sets
+  // hasUnknown.
+  {
+    auto* call = builder.makeCall("foo", {}, Type::i32);
+    auto* expr =
+      builder.makeBinary(EqInt32, builder.makeLocalGet(0, Type::i32), call);
+    auto parsed = ParsedAndedConstraints::parse(expr);
+    EXPECT_TRUE(parsed.empty());
+    EXPECT_TRUE(parsed.hasUnknown);
+  }
+
+  // 5. Comparison where left is not a local.get: unhandled, sets hasUnknown.
+  {
+    auto* expr = builder.makeBinary(EqInt32,
+                                    builder.makeConst(Literal(int32_t(1))),
+                                    builder.makeConst(Literal(int32_t(2))));
+    auto parsed = ParsedAndedConstraints::parse(expr);
+    EXPECT_TRUE(parsed.empty());
+    EXPECT_TRUE(parsed.hasUnknown);
+  }
+  // Ditto, local on right.
+  {
+    auto* expr = builder.makeBinary(EqInt32,
+                                    builder.makeConst(Literal(int32_t(1))),
+                                    builder.makeLocalGet(0, Type::i32));
+    auto parsed = ParsedAndedConstraints::parse(expr);
+    EXPECT_TRUE(parsed.empty());
+    EXPECT_TRUE(parsed.hasUnknown);
+  }
+
+  // 6. Binary operation that is not a comparison or AND (e.g. Add, Sub, Mul,
+  // Or, Xor): sets hasUnknown.
+  for (auto op : {AddInt32, SubInt32, MulInt32, OrInt32, XorInt32}) {
+    auto* expr = builder.makeBinary(op,
+                                    builder.makeLocalGet(0, Type::i32),
+                                    builder.makeConst(Literal(int32_t(1))));
+    auto parsed = ParsedAndedConstraints::parse(expr);
+    EXPECT_TRUE(parsed.empty());
+    EXPECT_TRUE(parsed.hasUnknown);
+  }
+}
+
+TEST(ConstraintTest, ParseRefEq) {
+  Module wasm;
+  Builder builder(wasm);
+  auto anyref = Type(HeapType::any, Nullable);
+
+  // 1. ref.eq with local.get on both sides.
+  {
+    auto* expr = builder.makeRefEq(builder.makeLocalGet(0, anyref),
+                                   builder.makeLocalGet(1, anyref));
+    auto parsed = ParsedAndedConstraints::parse(expr);
+    EXPECT_FALSE(parsed.hasUnknown);
+    ASSERT_EQ(parsed.size(), 1);
+    EXPECT_EQ(parsed[0], (LocalConstraint{0, Constraint{Eq, {Index(1)}}}));
+  }
+
+  // 2. ref.eq with local.get and ref.null.
+  {
+    auto* expr = builder.makeRefEq(builder.makeLocalGet(0, anyref),
+                                   builder.makeRefNull(HeapType::any));
+    auto parsed = ParsedAndedConstraints::parse(expr);
+    EXPECT_FALSE(parsed.hasUnknown);
+    ASSERT_EQ(parsed.size(), 1);
+    EXPECT_EQ(
+      parsed[0],
+      (LocalConstraint{0, Constraint{Eq, {Literal::makeNull(HeapType::any)}}}));
+  }
+
+  // 3. ref.eq where left is not a local.get (e.g. null on left): sets
+  // hasUnknown.
+  {
+    auto* expr = builder.makeRefEq(builder.makeRefNull(HeapType::any),
+                                   builder.makeLocalGet(0, anyref));
+    auto parsed = ParsedAndedConstraints::parse(expr);
+    EXPECT_TRUE(parsed.empty());
+    EXPECT_TRUE(parsed.hasUnknown);
+  }
+
+  // 4. ref.eq where right is not a term (e.g. call): sets hasUnknown.
+  {
+    auto* call = builder.makeCall("foo", {}, anyref);
+    auto* expr = builder.makeRefEq(builder.makeLocalGet(0, anyref), call);
+    auto parsed = ParsedAndedConstraints::parse(expr);
+    EXPECT_TRUE(parsed.empty());
+    EXPECT_TRUE(parsed.hasUnknown);
+  }
+}
+
+TEST(ConstraintTest, ParseAnd) {
+  Module wasm;
+  Builder builder(wasm);
+
+  // 1. AND over two valid comparisons: both constraints returned.
+  {
+    auto* left = builder.makeBinary(EqInt32,
+                                    builder.makeLocalGet(0, Type::i32),
+                                    builder.makeConst(Literal(int32_t(1))));
+    auto* right = builder.makeBinary(EqInt32,
+                                     builder.makeLocalGet(1, Type::i32),
+                                     builder.makeConst(Literal(int32_t(2))));
+    auto* expr = builder.makeBinary(AndInt32, left, right);
+    auto parsed = ParsedAndedConstraints::parse(expr);
+    EXPECT_FALSE(parsed.hasUnknown);
+    ASSERT_EQ(parsed.size(), 2);
+    // Work stack processes left then right.
+    EXPECT_EQ(parsed[0],
+              (LocalConstraint{0, Constraint{Eq, {Literal(int32_t(1))}}}));
+    EXPECT_EQ(parsed[1],
+              (LocalConstraint{1, Constraint{Eq, {Literal(int32_t(2))}}}));
+  }
+
+  // 2. AND with known constraint and unknown expression (call): Parses the
+  // constraint and also sets hasUnknown.
+  {
+    auto* left = builder.makeBinary(EqInt32,
+                                    builder.makeLocalGet(0, Type::i32),
+                                    builder.makeConst(Literal(int32_t(10))));
+    auto* right = builder.makeCall("unknown", {}, Type::i32);
+    auto* expr = builder.makeBinary(AndInt32, left, right);
+    auto parsed = ParsedAndedConstraints::parse(expr);
+    EXPECT_TRUE(parsed.hasUnknown);
+    ASSERT_EQ(parsed.size(), 1);
+    EXPECT_EQ(parsed[0],
+              (LocalConstraint{0, Constraint{Eq, {Literal(int32_t(10))}}}));
+  }
+
+  // 3. Same as above with unknown on left:
+  {
+    auto* left = builder.makeCall("unknown", {}, Type::i32);
+    auto* right = builder.makeBinary(EqInt32,
+                                     builder.makeLocalGet(0, Type::i32),
+                                     builder.makeConst(Literal(int32_t(10))));
+    auto* expr = builder.makeBinary(AndInt32, left, right);
+    auto parsed = ParsedAndedConstraints::parse(expr);
+    EXPECT_TRUE(parsed.hasUnknown);
+    ASSERT_EQ(parsed.size(), 1);
+    EXPECT_EQ(parsed[0],
+              (LocalConstraint{0, Constraint{Eq, {Literal(int32_t(10))}}}));
+  }
+
+  // 4. AND with known constraint and unhandled binary op (e.g. Add):
+  {
+    auto* left = builder.makeBinary(EqInt32,
+                                    builder.makeLocalGet(0, Type::i32),
+                                    builder.makeConst(Literal(int32_t(1))));
+    auto* right = builder.makeBinary(AddInt32,
+                                     builder.makeLocalGet(1, Type::i32),
+                                     builder.makeConst(Literal(int32_t(2))));
+    auto* expr = builder.makeBinary(AndInt32, left, right);
+    auto parsed = ParsedAndedConstraints::parse(expr);
+    EXPECT_TRUE(parsed.hasUnknown);
+    ASSERT_EQ(parsed.size(), 1);
+    EXPECT_EQ(parsed[0],
+              (LocalConstraint{0, Constraint{Eq, {Literal(int32_t(1))}}}));
+  }
+
+  // 5. AND with known constraint and unhandled unary op (e.g. Clz):
+  {
+    auto* left = builder.makeBinary(EqInt32,
+                                    builder.makeLocalGet(0, Type::i32),
+                                    builder.makeConst(Literal(int32_t(1))));
+    auto* right =
+      builder.makeUnary(ClzInt32, builder.makeLocalGet(1, Type::i32));
+    auto* expr = builder.makeBinary(AndInt32, left, right);
+    auto parsed = ParsedAndedConstraints::parse(expr);
+    EXPECT_TRUE(parsed.hasUnknown);
+    ASSERT_EQ(parsed.size(), 1);
+    EXPECT_EQ(parsed[0],
+              (LocalConstraint{0, Constraint{Eq, {Literal(int32_t(1))}}}));
+  }
+
+  // 6. AND with known constraint and unhandled eqz argument:
+  {
+    auto* left = builder.makeBinary(EqInt32,
+                                    builder.makeLocalGet(0, Type::i32),
+                                    builder.makeConst(Literal(int32_t(1))));
+    auto* right =
+      builder.makeUnary(EqZInt32, builder.makeCall("foo", {}, Type::i32));
+    auto* expr = builder.makeBinary(AndInt32, left, right);
+    auto parsed = ParsedAndedConstraints::parse(expr);
+    EXPECT_TRUE(parsed.hasUnknown);
+    ASSERT_EQ(parsed.size(), 1);
+    EXPECT_EQ(parsed[0],
+              (LocalConstraint{0, Constraint{Eq, {Literal(int32_t(1))}}}));
+  }
+
+  // 7. AND with two unknowns:
+  {
+    auto* left = builder.makeCall("foo", {}, Type::i32);
+    auto* right = builder.makeCall("bar", {}, Type::i32);
+    auto* expr = builder.makeBinary(AndInt32, left, right);
+    auto parsed = ParsedAndedConstraints::parse(expr);
+    EXPECT_TRUE(parsed.hasUnknown);
+    EXPECT_TRUE(parsed.empty());
+  }
+}
+
+TEST(ConstraintTest, ParseOtherUnknowns) {
+  Module wasm;
+  Builder builder(wasm);
+
+  // General expression types not handled by parse:
+  for (Expression* expr : {
+         (Expression*)builder.makeCall("foo", {}, Type::i32),
+         (Expression*)builder.makeConst(Literal(int32_t(42))),
+         (Expression*)builder.makeLocalGet(0, Type::i32),
+         (Expression*)builder.makeNop(),
+         (Expression*)builder.makeBlock(),
+       }) {
+    auto parsed = ParsedAndedConstraints::parse(expr);
+    EXPECT_TRUE(parsed.empty());
+    EXPECT_TRUE(parsed.hasUnknown);
+  }
+
+  // Contrast parse vs parseCondition for a bare local.get:
+  // parse treats it as an unhandled expression (unknown), while
+  // parseCondition recognizes it as x != 0 in a condition context.
+  auto* get = builder.makeLocalGet(0, Type::i32);
+  auto parsedAsExpr = ParsedAndedConstraints::parse(get);
+  EXPECT_TRUE(parsedAsExpr.empty());
+  EXPECT_TRUE(parsedAsExpr.hasUnknown);
+
+  auto parsedAsCondition = ParsedAndedConstraints::parseCondition(get);
+  EXPECT_FALSE(parsedAsCondition.hasUnknown);
+  ASSERT_EQ(parsedAsCondition.size(), 1);
+  EXPECT_EQ(parsedAsCondition[0],
+            (LocalConstraint{0, Constraint{Ne, {Literal(int32_t(0))}}}));
+}
diff --git a/test/gtest/effects.cpp b/test/gtest/effects.cpp
new file mode 100644
index 00000000000..4b8ee187e69
--- /dev/null
+++ b/test/gtest/effects.cpp
@@ -0,0 +1,113 @@
+/*
+ * Copyright 2026 WebAssembly Community Group participants
+ *
+ * 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.
+ */
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+#include "ir/effects.h"
+#include "matchers/effects.h"
+#include "parser/wat-parser.h"
+#include "wasm.h"
+
+using namespace wasm;
+using namespace testing;
+
+namespace {
+
+class EffectAnalyzerTest : public Test {
+protected:
+  Module wasm;
+  PassOptions options;
+
+  void SetUp() override { wasm.features = FeatureSet::All; }
+};
+
+TEST_F(EffectAnalyzerTest, Suspend) {
+  auto moduleText = R"wasm(
+    (module
+      (tag $tag)
+      (func $test
+        (suspend $tag)
+      )
+    )
+  )wasm";
+
+  auto parseResult = WATParser::parseModule(wasm, moduleText);
+  ASSERT_FALSE(parseResult.getErr());
+
+  auto* func = wasm.getFunction("test");
+  ASSERT_NE(func, nullptr);
+
+  EffectAnalyzer effects(options, wasm, func->body);
+
+  // Suspension detection
+  EXPECT_TRUE(effects.suspends);
+  EXPECT_THAT(&effects, Suspends());
+  EXPECT_TRUE(effects.getSideEffects() & EffectAnalyzer::SideEffects::Suspends);
+
+  // Suspending executes arbitrary other code in the handler before resuming,
+  // modeled as a call.
+  EXPECT_TRUE(effects.calls);
+  EXPECT_THAT(&effects, Calls());
+
+  // Accesses all global mutable state via calls
+  EXPECT_TRUE(effects.accessesMemory());
+  EXPECT_TRUE(effects.accessesSharedMemory());
+  EXPECT_TRUE(effects.accessesTable());
+  EXPECT_TRUE(effects.accessesMutableStruct());
+  EXPECT_TRUE(effects.accessesSharedMutableStruct());
+  EXPECT_TRUE(effects.accessesArray());
+  EXPECT_TRUE(effects.accessesSharedArray());
+  EXPECT_TRUE(effects.writesGlobalState());
+  EXPECT_TRUE(effects.readsMutableGlobalState());
+  EXPECT_TRUE(effects.accessesSharedGlobalState());
+
+  // Control flow & side effect queries
+  EXPECT_TRUE(effects.transfersControlFlow());
+  EXPECT_TRUE(effects.hasNonTrapSideEffects());
+  EXPECT_TRUE(effects.hasSideEffects());
+  EXPECT_TRUE(effects.hasUnremovableSideEffects());
+}
+
+TEST_F(EffectAnalyzerTest, UnknownCall) {
+  auto moduleText = R"wasm(
+    (module
+      (func $callee)
+      (func $caller
+        (call $callee)
+      )
+    )
+  )wasm";
+
+  auto parseResult = WATParser::parseModule(wasm, moduleText);
+  ASSERT_FALSE(parseResult.getErr());
+
+  auto* caller = wasm.getFunction("caller");
+  ASSERT_NE(caller, nullptr);
+
+  // With stack switching enabled, unknown calls conservatively assume
+  // suspension.
+  wasm.features.setStackSwitching(true);
+  EffectAnalyzer effectsWithStackSwitch(options, wasm, caller->body);
+  EXPECT_TRUE(effectsWithStackSwitch.suspends);
+
+  // With stack switching disabled, calls do not suspend.
+  wasm.features.setStackSwitching(false);
+  EffectAnalyzer effectsWithoutStackSwitch(options, wasm, caller->body);
+  EXPECT_FALSE(effectsWithoutStackSwitch.suspends);
+}
+
+} // anonymous namespace
diff --git a/test/gtest/matchers/effects.h b/test/gtest/matchers/effects.h
index 689850f92dc..b1bbbad57dc 100644
--- a/test/gtest/matchers/effects.h
+++ b/test/gtest/matchers/effects.h
@@ -45,6 +45,7 @@ MATCHER(Throws, "") { return arg->throws_; }
 MATCHER(DanglingPop, "") { return arg->danglingPop; }
 MATCHER(MayNotReturn, "") { return arg->mayNotReturn; }
 MATCHER(HasReturnCallThrow, "") { return arg->hasReturnCallThrow; }
+MATCHER(Suspends, "") { return arg->suspends; }
 
 } // namespace wasm
 
diff --git a/test/gtest/sizes.cpp b/test/gtest/sizes.cpp
new file mode 100644
index 00000000000..913427f617e
--- /dev/null
+++ b/test/gtest/sizes.cpp
@@ -0,0 +1,124 @@
+#include "wasm.h"
+#include "gtest/gtest.h"
+
+using namespace wasm;
+
+// Verify that Expression and its derived classes maintain their expected sizes
+// on linux64 (specifically avoiding regressions in tail-padding reuse and field
+// ordering).
+TEST(SizesTest, ExpressionSizes) {
+#if !defined(__linux__) || !defined(__x86_64__)
+  GTEST_SKIP() << "This test's numbers are for linux64";
+#else
+  EXPECT_EQ(sizeof(Expression), 16u);
+  EXPECT_EQ(sizeof(Block), 56u);
+  EXPECT_EQ(sizeof(If), 40u);
+  EXPECT_EQ(sizeof(Loop), 32u);
+  EXPECT_EQ(sizeof(Break), 40u);
+  EXPECT_EQ(sizeof(Switch), 72u);
+  EXPECT_EQ(sizeof(Call), 56u);
+  EXPECT_EQ(sizeof(CallIndirect), 72u);
+  EXPECT_EQ(sizeof(LocalGet), 16u);
+  EXPECT_EQ(sizeof(LocalSet), 24u);
+  EXPECT_EQ(sizeof(GlobalGet), 24u);
+  EXPECT_EQ(sizeof(GlobalSet), 32u);
+  EXPECT_EQ(sizeof(Load), 48u);
+  EXPECT_EQ(sizeof(Store), 64u);
+  EXPECT_EQ(sizeof(Const), 40u);
+  EXPECT_EQ(sizeof(Unary), 24u);
+  EXPECT_EQ(sizeof(Binary), 32u);
+  EXPECT_EQ(sizeof(Select), 40u);
+  EXPECT_EQ(sizeof(Drop), 24u);
+  EXPECT_EQ(sizeof(Return), 24u);
+  EXPECT_EQ(sizeof(MemorySize), 24u);
+  EXPECT_EQ(sizeof(MemoryGrow), 32u);
+  EXPECT_EQ(sizeof(Nop), 16u);
+  EXPECT_EQ(sizeof(Unreachable), 16u);
+  EXPECT_EQ(sizeof(AtomicRMW), 56u);
+  EXPECT_EQ(sizeof(AtomicCmpxchg), 56u);
+  EXPECT_EQ(sizeof(AtomicWait), 64u);
+  EXPECT_EQ(sizeof(AtomicNotify), 48u);
+  EXPECT_EQ(sizeof(AtomicFence), 16u);
+  EXPECT_EQ(sizeof(Pause), 16u);
+  EXPECT_EQ(sizeof(SIMDExtract), 24u);
+  EXPECT_EQ(sizeof(SIMDReplace), 32u);
+  EXPECT_EQ(sizeof(SIMDShuffle), 48u);
+  EXPECT_EQ(sizeof(SIMDTernary), 40u);
+  EXPECT_EQ(sizeof(SIMDShift), 32u);
+  EXPECT_EQ(sizeof(SIMDLoad), 48u);
+  EXPECT_EQ(sizeof(SIMDLoadStoreLane), 64u);
+  EXPECT_EQ(sizeof(MemoryInit), 56u);
+  EXPECT_EQ(sizeof(DataDrop), 24u);
+  EXPECT_EQ(sizeof(MemoryCopy), 56u);
+  EXPECT_EQ(sizeof(MemoryFill), 48u);
+  EXPECT_EQ(sizeof(Pop), 16u);
+  EXPECT_EQ(sizeof(RefNull), 16u);
+  EXPECT_EQ(sizeof(RefIsNull), 24u);
+  EXPECT_EQ(sizeof(RefFunc), 24u);
+  EXPECT_EQ(sizeof(RefEq), 32u);
+  EXPECT_EQ(sizeof(TableGet), 32u);
+  EXPECT_EQ(sizeof(TableSet), 40u);
+  EXPECT_EQ(sizeof(TableSize), 24u);
+  EXPECT_EQ(sizeof(TableGrow), 40u);
+  EXPECT_EQ(sizeof(TableFill), 48u);
+  EXPECT_EQ(sizeof(TableCopy), 56u);
+  EXPECT_EQ(sizeof(TableInit), 56u);
+  EXPECT_EQ(sizeof(ElemDrop), 24u);
+  EXPECT_EQ(sizeof(Try), 104u);
+  EXPECT_EQ(sizeof(TryTable), 152u);
+  EXPECT_EQ(sizeof(Throw), 56u);
+  EXPECT_EQ(sizeof(Rethrow), 24u);
+  EXPECT_EQ(sizeof(ThrowRef), 24u);
+  EXPECT_EQ(sizeof(TupleMake), 48u);
+  EXPECT_EQ(sizeof(TupleExtract), 24u);
+  EXPECT_EQ(sizeof(RefI31), 24u);
+  EXPECT_EQ(sizeof(I31Get), 24u);
+  EXPECT_EQ(sizeof(CallRef), 56u);
+  EXPECT_EQ(sizeof(RefTest), 32u);
+  EXPECT_EQ(sizeof(RefCast), 32u);
+  EXPECT_EQ(sizeof(RefGetDesc), 24u);
+  EXPECT_EQ(sizeof(BrOn), 48u);
+  EXPECT_EQ(sizeof(StructNew), 56u);
+  EXPECT_EQ(sizeof(StructGet), 24u);
+  EXPECT_EQ(sizeof(StructSet), 32u);
+  EXPECT_EQ(sizeof(StructRMW), 40u);
+  EXPECT_EQ(sizeof(StructCmpxchg), 40u);
+  EXPECT_EQ(sizeof(ArrayNew), 32u);
+  EXPECT_EQ(sizeof(ArrayNewData), 40u);
+  EXPECT_EQ(sizeof(ArrayNewElem), 40u);
+  EXPECT_EQ(sizeof(ArrayNewFixed), 48u);
+  EXPECT_EQ(sizeof(ArrayGet), 32u);
+  EXPECT_EQ(sizeof(ArraySet), 40u);
+  EXPECT_EQ(sizeof(ArrayLoad), 48u);
+  EXPECT_EQ(sizeof(ArrayStore), 56u);
+  EXPECT_EQ(sizeof(ArrayLen), 24u);
+  EXPECT_EQ(sizeof(ArrayCopy), 56u);
+  EXPECT_EQ(sizeof(ArrayFill), 48u);
+  EXPECT_EQ(sizeof(ArrayInitData), 56u);
+  EXPECT_EQ(sizeof(ArrayInitElem), 56u);
+  EXPECT_EQ(sizeof(ArrayRMW), 40u);
+  EXPECT_EQ(sizeof(ArrayCmpxchg), 48u);
+  EXPECT_EQ(sizeof(RefAs), 24u);
+  EXPECT_EQ(sizeof(StringNew), 40u);
+  EXPECT_EQ(sizeof(StringConst), 24u);
+  EXPECT_EQ(sizeof(StringMeasure), 24u);
+  EXPECT_EQ(sizeof(StringEncode), 40u);
+  EXPECT_EQ(sizeof(StringConcat), 32u);
+  EXPECT_EQ(sizeof(StringEq), 32u);
+  EXPECT_EQ(sizeof(StringTest), 24u);
+  EXPECT_EQ(sizeof(StringWTF16Get), 32u);
+  EXPECT_EQ(sizeof(StringSliceWTF), 40u);
+  EXPECT_EQ(sizeof(ContNew), 24u);
+  EXPECT_EQ(sizeof(ContBind), 56u);
+  EXPECT_EQ(sizeof(Suspend), 56u);
+  EXPECT_EQ(sizeof(Resume), 152u);
+  EXPECT_EQ(sizeof(ResumeThrow), 160u);
+  EXPECT_EQ(sizeof(StackSwitch), 64u);
+  EXPECT_EQ(sizeof(StructWait), 56u);
+  EXPECT_EQ(sizeof(WideIntAddSub), 48u);
+  EXPECT_EQ(sizeof(WideIntMul), 32u);
+  EXPECT_EQ(sizeof(WaitqueueNew), 16u);
+  EXPECT_EQ(sizeof(WaitqueueNotify), 32u);
+  EXPECT_EQ(sizeof(Publish), 24u);
+#endif
+}
diff --git a/test/gtest/type-builder.cpp b/test/gtest/type-builder.cpp
index e6ce3bce61b..eca40791eaa 100644
--- a/test/gtest/type-builder.cpp
+++ b/test/gtest/type-builder.cpp
@@ -585,6 +585,70 @@ TEST_F(TypeTest, CanonicalizeDescriptors) {
   EXPECT_NE(built[0].getRecGroup(), built[4].getRecGroup());
 }
 
+TEST_F(TypeTest, MismatchedDescriptorFinality) {
+  // Described type is final, descriptor type is open.
+  {
+    TypeBuilder builder(2);
+    builder.createRecGroup(0, 2);
+    builder[0] = Struct{};
+    builder[1].setOpen() = Struct{};
+    builder[0].descriptor(builder[1]);
+    builder[1].describes(builder[0]);
+
+    auto result = builder.build();
+    EXPECT_FALSE(result);
+    const auto* error = result.getError();
+    ASSERT_TRUE(error);
+    EXPECT_EQ(error->reason,
+              TypeBuilder::ErrorReasonKind::MismatchedDescriptorFinality);
+    EXPECT_EQ(error->index, 0u);
+  }
+
+  // Described type is open, descriptor type is final.
+  {
+    TypeBuilder builder(2);
+    builder.createRecGroup(0, 2);
+    builder[0].setOpen() = Struct{};
+    builder[1] = Struct{};
+    builder[0].descriptor(builder[1]);
+    builder[1].describes(builder[0]);
+
+    auto result = builder.build();
+    EXPECT_FALSE(result);
+    const auto* error = result.getError();
+    ASSERT_TRUE(error);
+    EXPECT_EQ(error->reason,
+              TypeBuilder::ErrorReasonKind::MismatchedDescriptorFinality);
+    EXPECT_EQ(error->index, 0u);
+  }
+
+  // Both are final: succeeds.
+  {
+    TypeBuilder builder(2);
+    builder.createRecGroup(0, 2);
+    builder[0] = Struct{};
+    builder[1] = Struct{};
+    builder[0].descriptor(builder[1]);
+    builder[1].describes(builder[0]);
+
+    auto result = builder.build();
+    EXPECT_TRUE(result);
+  }
+
+  // Both are open: succeeds.
+  {
+    TypeBuilder builder(2);
+    builder.createRecGroup(0, 2);
+    builder[0].setOpen() = Struct{};
+    builder[1].setOpen() = Struct{};
+    builder[0].descriptor(builder[1]);
+    builder[1].describes(builder[0]);
+
+    auto result = builder.build();
+    EXPECT_TRUE(result);
+  }
+}
+
 TEST_F(TypeTest, CanonicalizeFinal) {
   // Types are different if their finality flag is different.
   TypeBuilder builder(2);
diff --git a/test/gtest/type-updating.cpp b/test/gtest/type-updating.cpp
index c18ab54eac4..bda4b404593 100644
--- a/test/gtest/type-updating.cpp
+++ b/test/gtest/type-updating.cpp
@@ -189,7 +189,7 @@ TEST_F(IndirectCallEffectsTest, MapToNewType) {
   // Because the type is brand new, we do *not* treat its absence in
   // `indirectCallEffects` as 'unknown effects' like in `DestHasUnknownEffects`.
   // Instead $"new type" just gains $A's effects. We do a pointer comparison
-  // here since the effects object can be re-used unchanged.
+  // here since the effects object can be reused unchanged.
   EXPECT_THAT(merged, UnorderedElementsAre(Pair("new type", effectsA)));
 }
 
diff --git a/test/lit/basic/exception-handling-legacy.wast b/test/lit/basic/exception-handling-legacy.wast
index 3f019d5323e..151e74a1ce3 100644
--- a/test/lit/basic/exception-handling-legacy.wast
+++ b/test/lit/basic/exception-handling-legacy.wast
@@ -697,7 +697,7 @@
   ;; CHECK-BIN-NEXT: )
   (func $branch-and-delegate-target-same-try-label
     ;; When there are both a branch and a delegate that target the same try
-    ;; label. Because binaryen only allows blocks and loops to be targetted by
+    ;; label. Because binaryen only allows blocks and loops to be targeted by
     ;; branches, we wrap the try with a block and make branches that block
     ;; instead, resulting in the br and delegate target different labels in the
     ;; output.
@@ -872,7 +872,7 @@
   ;; CHECK-BIN-NEXT: )
   (func $branch-and-rethrow-target-same-try-label
     ;; When there are both a branch and a rethrow that target the same try
-    ;; label. Because binaryen only allows blocks and loops to be targetted by
+    ;; label. Because binaryen only allows blocks and loops to be targeted by
     ;; branches, we wrap the try with a block and make branches that block
     ;; instead, resulting in the br and rethrow target different labels in the
     ;; output.
diff --git a/test/lit/ctor-eval/gc-desc.wast b/test/lit/ctor-eval/gc-desc.wast
index 95140024dee..1ee744fd68b 100644
--- a/test/lit/ctor-eval/gc-desc.wast
+++ b/test/lit/ctor-eval/gc-desc.wast
@@ -6,8 +6,8 @@
     ;; CHECK:      (rec
     ;; CHECK-NEXT:  (type $struct (sub (descriptor $desc) (struct)))
     (type $struct (sub (descriptor $desc) (struct)))
-    ;; CHECK:       (type $desc (describes $struct) (struct))
-    (type $desc (describes $struct) (struct))
+    ;; CHECK:       (type $desc (sub (describes $struct) (struct)))
+    (type $desc (sub (describes $struct) (struct)))
   )
   ;; CHECK:      (type $2 (func))
 
diff --git a/test/lit/ctor-eval/multivalue-local.wast b/test/lit/ctor-eval/multivalue-local.wast
index 306e26a41e4..5ae46cf2b4c 100644
--- a/test/lit/ctor-eval/multivalue-local.wast
+++ b/test/lit/ctor-eval/multivalue-local.wast
@@ -32,7 +32,7 @@
 
   (call $import)
 
-  ;; Use the locals so they are not trivally removed.
+  ;; Use the locals so they are not trivially removed.
   (i32.add
    (local.get $0)
    (tuple.extract 2 0
diff --git a/test/lit/ctor-eval/return_call.wast b/test/lit/ctor-eval/return_call.wast
index 20dace4dbc9..06cd3619d5f 100644
--- a/test/lit/ctor-eval/return_call.wast
+++ b/test/lit/ctor-eval/return_call.wast
@@ -484,3 +484,59 @@
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (call $import)
 ;; CHECK-NEXT: )
+(module
+  ;; Return call with a non-serializable parameter (continuation) stops
+  ;; evaluating without crashing when partially evaluating the caller.
+  ;; CHECK:      (type $func (func))
+  (type $func (func))
+  ;; CHECK:      (type $cont (cont $func))
+  (type $cont (cont $func))
+
+  ;; CHECK:      (type $2 (func (param (ref $cont))))
+
+  ;; CHECK:      (global $g (mut i32) (i32.const 2))
+  (global $g (export "g") (mut i32) (i32.const 0))
+
+  ;; CHECK:      (elem declare func $callee)
+  (elem declare func $callee)
+
+  ;; CHECK:      (export "g" (global $g))
+
+  ;; CHECK:      (export "test" (func $test_3))
+
+  ;; CHECK:      (func $callee (type $func)
+  ;; CHECK-NEXT:  (nop)
+  ;; CHECK-NEXT: )
+  (func $callee (type $func)
+    (nop)
+  )
+
+  ;; CHECK:      (func $target (type $2) (param $0 (ref $cont))
+  ;; CHECK-NEXT:  (nop)
+  ;; CHECK-NEXT: )
+  (func $target (param (ref $cont))
+    (nop)
+  )
+
+  (func $test (export "test")
+    (global.set $g
+      (i32.const 1)
+    )
+    (global.set $g
+      (i32.const 2)
+    )
+    (return_call $target
+      (cont.new $cont
+        (ref.func $callee)
+      )
+    )
+  )
+)
+
+;; CHECK:      (func $test_3 (type $func)
+;; CHECK-NEXT:  (return_call $target
+;; CHECK-NEXT:   (cont.new $cont
+;; CHECK-NEXT:    (ref.func $callee)
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:  )
+;; CHECK-NEXT: )
diff --git a/test/lit/exec/resume_throw_ref.wast b/test/lit/exec/resume_throw_ref.wast
new file mode 100644
index 00000000000..43518f3b2e3
--- /dev/null
+++ b/test/lit/exec/resume_throw_ref.wast
@@ -0,0 +1,24 @@
+;; NOTE: Assertions have been generated by update_lit_checks.py --all-items --output=fuzz-exec and should not be edited.
+
+;; RUN: wasm-opt %s -all --fuzz-exec-before -q -o /dev/null 2>&1 | filecheck %s
+
+(module
+ (type $empty (func))
+ (type $cont (cont $empty))
+
+ (func $empty
+ )
+
+ ;; CHECK:      [fuzz-exec] export test
+ ;; CHECK-NEXT: [trap null ref]
+ (func $test (export "test")
+  ;; The exnref here is null, which we trap on.
+  (resume_throw_ref $cont
+   (ref.null noexn)
+   (cont.new $cont
+    (ref.func $empty)
+   )
+  )
+ )
+)
+
diff --git a/test/lit/fuzz-types.test b/test/lit/fuzz-types.test
index 9d39339af56..ffcac612584 100644
--- a/test/lit/fuzz-types.test
+++ b/test/lit/fuzz-types.test
@@ -5,56 +5,56 @@
 ;; CHECK-NEXT: (rec
 ;; CHECK-NEXT:  (type $0 (sub (shared (func (param i64 f64 exnref (ref null $0)) (result (ref cont))))))
 ;; CHECK-NEXT:  (type $1 (shared (descriptor $2) (struct)))
-;; CHECK-NEXT:  (type $2 (shared (describes $1) (descriptor $4) (struct)))
-;; CHECK-NEXT:  (type $3 (sub (array (mut (ref null $0)))))
-;; CHECK-NEXT:  (type $4 (sub (shared (describes $2) (struct (field (mut i8)) (field (ref null $1)) (field (mut v128)) (field (mut (ref (shared any))))))))
+;; CHECK-NEXT:  (type $2 (shared (describes $1) (descriptor $4) (struct (field (mut v128)) (field (mut (ref $4))) (field (mut v128)) (field (mut i32)) (field f32))))
+;; CHECK-NEXT:  (type $3 (array i8))
+;; CHECK-NEXT:  (type $4 (shared (describes $2) (struct)))
 ;; CHECK-NEXT: )
 ;; CHECK-NEXT: (rec
-;; CHECK-NEXT:  (type $5 (shared (descriptor $6) (struct)))
-;; CHECK-NEXT:  (type $6 (sub (shared (describes $5) (descriptor $7) (struct (field (mut i8)) (field (mut i32)) (field (mut i64))))))
-;; CHECK-NEXT:  (type $7 (sub (shared (describes $6) (descriptor $9) (struct (field (mut i64)) (field f32) (field i16) (field (mut f32))))))
-;; CHECK-NEXT:  (type $8 (sub (struct (field i32))))
-;; CHECK-NEXT:  (type $9 (shared (describes $7) (descriptor $11) (struct (field (mut i64)) (field (ref $5)))))
-;; CHECK-NEXT:  (type $10 (sub (func (param (ref $11) f32 (ref null $1) v128) (result f32))))
-;; CHECK-NEXT:  (type $11 (shared (describes $9) (struct (field (mut v128)))))
-;; CHECK-NEXT:  (type $12 (sub (descriptor $13) (struct (field i32) (field (mut (ref null $10))) (field i64) (field i32) (field (mut anyref)))))
-;; CHECK-NEXT:  (type $13 (sub (describes $12) (struct (field externref) (field (ref $10)) (field (mut i32)) (field (mut i16)) (field (mut (ref null $1))) (field i8))))
-;; CHECK-NEXT:  (type $14 (sub $8 (struct (field i32))))
+;; CHECK-NEXT:  (type $5 (shared (descriptor $6) (struct (field f64) (field (ref $7)) (field (mut f64)) (field (mut (ref null (shared eq)))) (field (ref $11)) (field (ref (shared any))))))
+;; CHECK-NEXT:  (type $6 (shared (describes $5) (descriptor $7) (struct (field (mut i32)) (field (mut i16)) (field i64) (field f32) (field (ref null $11)) (field (mut f64)))))
+;; CHECK-NEXT:  (type $7 (shared (describes $6) (descriptor $9) (struct (field i8) (field (mut f32)) (field (mut f64)) (field (mut i32)) (field (mut f32)) (field (mut i64)))))
+;; CHECK-NEXT:  (type $8 (sub (struct)))
+;; CHECK-NEXT:  (type $9 (shared (describes $7) (descriptor $11) (struct (field (mut v128)) (field (mut v128)) (field (mut f32)))))
+;; CHECK-NEXT:  (type $10 (func (param f32 f64 f32)))
+;; CHECK-NEXT:  (type $11 (shared (describes $9) (struct (field (ref (shared struct))) (field i32) (field f32) (field (mut (ref null (shared struct)))) (field i64) (field i32))))
+;; CHECK-NEXT:  (type $12 (sub (descriptor $13) (struct (field (mut i8)) (field f32) (field (mut v128)))))
+;; CHECK-NEXT:  (type $13 (sub (describes $12) (struct (field i32) (field (ref $10)) (field i8) (field (mut i64)))))
+;; CHECK-NEXT:  (type $14 (sub $8 (struct)))
 ;; CHECK-NEXT: )
 ;; CHECK-NEXT: (rec
-;; CHECK-NEXT:  (type $15 (sub final $8 (struct (field i32) (field f64))))
-;; CHECK-NEXT:  (type $16 (shared (func (param (ref $5) v128 (ref null $3) i64 i32 (ref any) (ref null $2)) (result (ref null $5) i32))))
-;; CHECK-NEXT:  (type $17 (sub final $12 (descriptor $18) (struct (field i32) (field (mut (ref null $10))) (field i64) (field i32) (field (mut anyref)))))
-;; CHECK-NEXT:  (type $18 (sub final $13 (describes $17) (struct (field (ref noextern)) (field (ref $10)) (field (mut i32)) (field (mut i16)) (field (mut (ref null $1))) (field i8))))
-;; CHECK-NEXT:  (type $19 (sub $8 (struct (field i32) (field (mut i8)))))
+;; CHECK-NEXT:  (type $15 (sub $8 (struct (field v128) (field (mut (ref null (shared struct)))))))
+;; CHECK-NEXT:  (type $16 (shared (func (param (ref null $10)) (result (ref $6) i32 f64))))
+;; CHECK-NEXT:  (type $17 (sub final $12 (descriptor $18) (struct (field (mut i8)) (field f32) (field (mut v128)) (field (ref $17)) (field (mut i8)) (field (mut eqref)))))
+;; CHECK-NEXT:  (type $18 (sub final $13 (describes $17) (struct (field i32) (field (ref $10)) (field i8) (field (mut i64)) (field (mut (ref null $11))) (field f64))))
+;; CHECK-NEXT:  (type $19 (sub $8 (struct (field (mut i8)) (field (mut v128)) (field v128) (field v128))))
 ;; CHECK-NEXT: )
-;; CHECK-NEXT: 
+;; CHECK-EMPTY:
 ;; CHECK-NEXT: Inhabitable types:
-;; CHECK-NEXT: 
+;; CHECK-EMPTY:
 ;; CHECK-NEXT: Built 20 types:
 ;; CHECK-NEXT: (rec
 ;; CHECK-NEXT:  (type $0 (sub (shared (func (param i64 f64 exnref (ref null $0)) (result (ref cont))))))
 ;; CHECK-NEXT:  (type $1 (shared (descriptor $2) (struct)))
-;; CHECK-NEXT:  (type $2 (shared (describes $1) (descriptor $4) (struct)))
-;; CHECK-NEXT:  (type $3 (sub (array (mut (ref null $0)))))
-;; CHECK-NEXT:  (type $4 (sub (shared (describes $2) (struct (field (mut i8)) (field (ref null $1)) (field (mut v128)) (field (mut (ref (shared any))))))))
+;; CHECK-NEXT:  (type $2 (shared (describes $1) (descriptor $4) (struct (field (mut v128)) (field (mut (ref $4))) (field (mut v128)) (field (mut i32)) (field f32))))
+;; CHECK-NEXT:  (type $3 (array i8))
+;; CHECK-NEXT:  (type $4 (shared (describes $2) (struct)))
 ;; CHECK-NEXT: )
 ;; CHECK-NEXT: (rec
-;; CHECK-NEXT:  (type $5 (shared (descriptor $6) (struct)))
-;; CHECK-NEXT:  (type $6 (sub (shared (describes $5) (descriptor $7) (struct (field (mut i8)) (field (mut i32)) (field (mut i64))))))
-;; CHECK-NEXT:  (type $7 (sub (shared (describes $6) (descriptor $9) (struct (field (mut i64)) (field f32) (field i16) (field (mut f32))))))
-;; CHECK-NEXT:  (type $8 (sub (struct (field i32))))
-;; CHECK-NEXT:  (type $9 (shared (describes $7) (descriptor $11) (struct (field (mut i64)) (field (ref null $5)))))
-;; CHECK-NEXT:  (type $10 (sub (func (param (ref $11) f32 (ref null $1) v128) (result f32))))
-;; CHECK-NEXT:  (type $11 (shared (describes $9) (struct (field (mut v128)))))
-;; CHECK-NEXT:  (type $12 (sub (descriptor $13) (struct (field i32) (field (mut (ref null $10))) (field i64) (field i32) (field (mut anyref)))))
-;; CHECK-NEXT:  (type $13 (sub (describes $12) (struct (field externref) (field (ref $10)) (field (mut i32)) (field (mut i16)) (field (mut (ref null $1))) (field i8))))
-;; CHECK-NEXT:  (type $14 (sub $8 (struct (field i32))))
+;; CHECK-NEXT:  (type $5 (shared (descriptor $6) (struct (field f64) (field (ref $7)) (field (mut f64)) (field (mut (ref null (shared eq)))) (field (ref $11)) (field (ref (shared any))))))
+;; CHECK-NEXT:  (type $6 (shared (describes $5) (descriptor $7) (struct (field (mut i32)) (field (mut i16)) (field i64) (field f32) (field (ref null $11)) (field (mut f64)))))
+;; CHECK-NEXT:  (type $7 (shared (describes $6) (descriptor $9) (struct (field i8) (field (mut f32)) (field (mut f64)) (field (mut i32)) (field (mut f32)) (field (mut i64)))))
+;; CHECK-NEXT:  (type $8 (sub (struct)))
+;; CHECK-NEXT:  (type $9 (shared (describes $7) (descriptor $11) (struct (field (mut v128)) (field (mut v128)) (field (mut f32)))))
+;; CHECK-NEXT:  (type $10 (func (param f32 f64 f32)))
+;; CHECK-NEXT:  (type $11 (shared (describes $9) (struct (field (ref (shared struct))) (field i32) (field f32) (field (mut (ref null (shared struct)))) (field i64) (field i32))))
+;; CHECK-NEXT:  (type $12 (sub (descriptor $13) (struct (field (mut i8)) (field f32) (field (mut v128)))))
+;; CHECK-NEXT:  (type $13 (sub (describes $12) (struct (field i32) (field (ref $10)) (field i8) (field (mut i64)))))
+;; CHECK-NEXT:  (type $14 (sub $8 (struct)))
 ;; CHECK-NEXT: )
 ;; CHECK-NEXT: (rec
-;; CHECK-NEXT:  (type $15 (sub final $8 (struct (field i32) (field f64))))
-;; CHECK-NEXT:  (type $16 (shared (func (param (ref $5) v128 (ref null $3) i64 i32 (ref any) (ref null $2)) (result (ref null $5) i32))))
-;; CHECK-NEXT:  (type $17 (sub final $12 (descriptor $18) (struct (field i32) (field (mut (ref null $10))) (field i64) (field i32) (field (mut anyref)))))
-;; CHECK-NEXT:  (type $18 (sub final $13 (describes $17) (struct (field nullexternref) (field (ref $10)) (field (mut i32)) (field (mut i16)) (field (mut (ref null $1))) (field i8))))
-;; CHECK-NEXT:  (type $19 (sub $8 (struct (field i32) (field (mut i8)))))
+;; CHECK-NEXT:  (type $15 (sub $8 (struct (field v128) (field (mut (ref null (shared struct)))))))
+;; CHECK-NEXT:  (type $16 (shared (func (param (ref null $10)) (result (ref $6) i32 f64))))
+;; CHECK-NEXT:  (type $17 (sub final $12 (descriptor $18) (struct (field (mut i8)) (field f32) (field (mut v128)) (field (ref null $17)) (field (mut i8)) (field (mut eqref)))))
+;; CHECK-NEXT:  (type $18 (sub final $13 (describes $17) (struct (field i32) (field (ref $10)) (field i8) (field (mut i64)) (field (mut (ref null $11))) (field f64))))
+;; CHECK-NEXT:  (type $19 (sub $8 (struct (field (mut i8)) (field (mut v128)) (field v128) (field v128))))
 ;; CHECK-NEXT: )
diff --git a/test/lit/help/wasm-as.test b/test/lit/help/wasm-as.test
index 5d27116d61d..e0948f13a4c 100644
--- a/test/lit/help/wasm-as.test
+++ b/test/lit/help/wasm-as.test
@@ -1,207 +1,207 @@
 ;; RUN: wasm-as --help | filecheck %s
 ;; CHECK: ================================================================================
 ;; CHECK-NEXT: wasm-as INFILE
-;; CHECK-NEXT:
-;; CHECK-NEXT: Assemble a .wat (WebAssembly text format) into a .wasm (WebAssembly binary
+;; CHECK-EMPTY:
+;; CHECK-NEXT: Assemble a .wat (WebAssembly text format) into a .wasm (WebAssembly binary 
 ;; CHECK-NEXT: format)
 ;; CHECK-NEXT: ================================================================================
-;; CHECK-NEXT:
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT: wasm-as options:
 ;; CHECK-NEXT: ----------------
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --output,-o                          Output file
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --validate,-v                        Control validation of the output module
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --debuginfo,-g                       Emit names section and debug info
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --source-map,-sm                     Emit source map to the specified file
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --source-map-url,-su                 Use specified string as source map URL
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --symbolmap,-s                       Emit a symbol map (indexes => names)
-;; CHECK-NEXT:
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT: Tool options:
 ;; CHECK-NEXT: -------------
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --mvp-features,-mvp                  Disable all non-MVP features
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --all-features,-all                  Enable all features
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --detect-features                    (deprecated - this flag does nothing)
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --quiet,-q                           Emit less verbose output and hide trivial
 ;; CHECK-NEXT:                                        warnings.
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --experimental-poppy                 Parse wast files as Poppy IR for testing
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --experimental-poppy                 Parse wast files as Poppy IR for testing 
 ;; CHECK-NEXT:                                        purposes.
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --emit-module-names                  Emit module names, even if not emitting
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --emit-module-names                  Emit module names, even if not emitting 
 ;; CHECK-NEXT:                                        the rest of the names section.
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-sign-ext                    Enable sign extension operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-sign-ext                   Disable sign extension operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-threads                     Enable atomic operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-threads                    Disable atomic operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-mutable-globals             Enable mutable globals
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-mutable-globals            Disable mutable globals
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --enable-nontrapping-float-to-int    Enable nontrapping float-to-int
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --enable-nontrapping-float-to-int    Enable nontrapping float-to-int 
 ;; CHECK-NEXT:                                        operations
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --disable-nontrapping-float-to-int   Disable nontrapping float-to-int
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --disable-nontrapping-float-to-int   Disable nontrapping float-to-int 
 ;; CHECK-NEXT:                                        operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-simd                        Enable SIMD operations and types
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-simd                       Disable SIMD operations and types
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-bulk-memory                 Enable bulk memory operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-bulk-memory                Disable bulk memory operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-bulk-memory-opt             Enable memory.copy and memory.fill
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-bulk-memory-opt            Disable memory.copy and memory.fill
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --enable-call-indirect-overlong      Enable LEB encoding of call-indirect
-;; CHECK-NEXT:                                        (Ignored for compatibility as it has no
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --enable-call-indirect-overlong      Enable LEB encoding of call-indirect 
+;; CHECK-NEXT:                                        (Ignored for compatibility as it has no 
 ;; CHECK-NEXT:                                        effect on Binaryen)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --disable-call-indirect-overlong     Disable LEB encoding of call-indirect
-;; CHECK-NEXT:                                        (Ignored for compatibility as it has no
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --disable-call-indirect-overlong     Disable LEB encoding of call-indirect 
+;; CHECK-NEXT:                                        (Ignored for compatibility as it has no 
 ;; CHECK-NEXT:                                        effect on Binaryen)
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-exception-handling          Enable exception handling operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-exception-handling         Disable exception handling operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-tail-call                   Enable tail call operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-tail-call                  Disable tail call operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-reference-types             Enable reference types
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-reference-types            Disable reference types
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-multivalue                  Enable multivalue functions
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-multivalue                 Disable multivalue functions
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-gc                          Enable garbage collection
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-gc                         Disable garbage collection
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-memory64                    Enable memory64
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-memory64                   Disable memory64
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-relaxed-simd                Enable relaxed SIMD
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-relaxed-simd               Disable relaxed SIMD
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-extended-const              Enable extended const expressions
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-extended-const             Disable extended const expressions
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-strings                     Enable strings
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-strings                    Disable strings
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-multimemory                 Enable multimemory
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-multimemory                Disable multimemory
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-stack-switching             Enable stack switching
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-stack-switching            Disable stack switching
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-shared-everything           Enable shared-everything threads
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-shared-everything          Disable shared-everything threads
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-fp16                        Enable float 16 operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-fp16                       Disable float 16 operations
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --enable-custom-descriptors          Enable custom descriptors (RTTs) and
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --enable-custom-descriptors          Enable custom descriptors (RTTs) and 
 ;; CHECK-NEXT:                                        exact references
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --disable-custom-descriptors         Disable custom descriptors (RTTs) and
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --disable-custom-descriptors         Disable custom descriptors (RTTs) and 
 ;; CHECK-NEXT:                                        exact references
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-multibyte                   Enable multibyte array loads and stores
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-multibyte                  Disable multibyte array loads and stores
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --enable-acquire-release-atomics     Enable acquire/release atomic memory
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --enable-acquire-release-atomics     Enable acquire/release atomic memory 
 ;; CHECK-NEXT:                                        operations
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --disable-acquire-release-atomics    Disable acquire/release atomic memory
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --disable-acquire-release-atomics    Disable acquire/release atomic memory 
 ;; CHECK-NEXT:                                        operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-custom-page-sizes           Enable custom page sizes
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-custom-page-sizes          Disable custom page sizes
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-wide-arithmetic             Enable wide arithmetic
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-wide-arithmetic            Disable wide arithmetic
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-compact-imports             Enable compact import section
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-compact-imports            Disable compact import section
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-relaxed-atomics             Enable relaxed atomic memory operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-relaxed-atomics            Disable relaxed atomic memory operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-typed-function-references   Deprecated compatibility flag
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-typed-function-references  Deprecated compatibility flag
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --no-validation,-n                   Disables validation, assumes inputs are
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --no-validation,-n                   Disables validation, assumes inputs are 
 ;; CHECK-NEXT:                                        correct
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --pass-arg,-pa                       An argument passed along to optimization
-;; CHECK-NEXT:                                        passes being run. Must be in the form
-;; CHECK-NEXT:                                        KEY@VALUE.  If KEY is the name of a pass
-;; CHECK-NEXT:                                        then it applies to the closest instance
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --pass-arg,-pa                       An argument passed along to optimization 
+;; CHECK-NEXT:                                        passes being run. Must be in the form 
+;; CHECK-NEXT:                                        KEY@VALUE.  If KEY is the name of a pass 
+;; CHECK-NEXT:                                        then it applies to the closest instance 
 ;; CHECK-NEXT:                                        of that pass before us. If KEY is not the
 ;; CHECK-NEXT:                                        name of a pass then it is a global option
-;; CHECK-NEXT:                                        that applies to all pass instances that
+;; CHECK-NEXT:                                        that applies to all pass instances that 
 ;; CHECK-NEXT:                                        read it.
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --closed-world,-cw                   Assume code outside of the module does
-;; CHECK-NEXT:                                        not inspect or interact with GC and
-;; CHECK-NEXT:                                        function references, even if they are
-;; CHECK-NEXT:                                        passed out. The outside may hold on to
-;; CHECK-NEXT:                                        them and pass them back in, but not
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --closed-world,-cw                   Assume code outside of the module does 
+;; CHECK-NEXT:                                        not inspect or interact with GC and 
+;; CHECK-NEXT:                                        function references, even if they are 
+;; CHECK-NEXT:                                        passed out. The outside may hold on to 
+;; CHECK-NEXT:                                        them and pass them back in, but not 
 ;; CHECK-NEXT:                                        inspect their contents or call them.
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --preserve-type-order                Preserve the order of types from the
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --preserve-type-order                Preserve the order of types from the 
 ;; CHECK-NEXT:                                        input (useful for debugging and testing)
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --generate-stack-ir                  generate StackIR during writing
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --optimize-stack-ir                  optimize StackIR during writing
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --print-stack-ir                     print StackIR during writing
-;; CHECK-NEXT:
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT: General options:
 ;; CHECK-NEXT: ----------------
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --version                            Output version information and exit
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --help,-h                            Show this help message and exit
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --debug,-d                           Print debug information to stderr
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
diff --git a/test/lit/help/wasm-ctor-eval.test b/test/lit/help/wasm-ctor-eval.test
index 59106345216..14cc82d65e1 100644
--- a/test/lit/help/wasm-ctor-eval.test
+++ b/test/lit/help/wasm-ctor-eval.test
@@ -1,214 +1,214 @@
 ;; RUN: wasm-ctor-eval --help | filecheck %s
 ;; CHECK: ================================================================================
 ;; CHECK-NEXT: wasm-ctor-eval INFILE
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT: Execute code at compile time
 ;; CHECK-NEXT: ================================================================================
-;; CHECK-NEXT:
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT: wasm-ctor-eval options:
 ;; CHECK-NEXT: -----------------------
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --output,-o                          Output file
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --emit-text,-S                       Emit text instead of binary for the
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --emit-text,-S                       Emit text instead of binary for the 
 ;; CHECK-NEXT:                                        output file
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --debuginfo,-g                       Emit names section and debug info
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --ctors,-c                           Comma-separated list of global
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --ctors,-c                           Comma-separated list of global 
 ;; CHECK-NEXT:                                        constructor functions to evaluate
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --kept-exports,-ke                   Comma-separated list of ctors whose
-;; CHECK-NEXT:                                        exports we keep around even if we eval
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --kept-exports,-ke                   Comma-separated list of ctors whose 
+;; CHECK-NEXT:                                        exports we keep around even if we eval 
 ;; CHECK-NEXT:                                        those ctors
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --ignore-external-input,-ipi         Assumes no env vars are to be read, stdin
 ;; CHECK-NEXT:                                        is empty, etc.
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --quiet,-q                           Do not emit verbose logging about the
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --quiet,-q                           Do not emit verbose logging about the 
 ;; CHECK-NEXT:                                        eval process
-;; CHECK-NEXT:
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT: Tool options:
 ;; CHECK-NEXT: -------------
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --mvp-features,-mvp                  Disable all non-MVP features
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --all-features,-all                  Enable all features
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --detect-features                    (deprecated - this flag does nothing)
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --quiet,-q                           Emit less verbose output and hide trivial
 ;; CHECK-NEXT:                                        warnings.
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --experimental-poppy                 Parse wast files as Poppy IR for testing
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --experimental-poppy                 Parse wast files as Poppy IR for testing 
 ;; CHECK-NEXT:                                        purposes.
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --emit-module-names                  Emit module names, even if not emitting
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --emit-module-names                  Emit module names, even if not emitting 
 ;; CHECK-NEXT:                                        the rest of the names section.
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-sign-ext                    Enable sign extension operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-sign-ext                   Disable sign extension operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-threads                     Enable atomic operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-threads                    Disable atomic operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-mutable-globals             Enable mutable globals
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-mutable-globals            Disable mutable globals
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --enable-nontrapping-float-to-int    Enable nontrapping float-to-int
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --enable-nontrapping-float-to-int    Enable nontrapping float-to-int 
 ;; CHECK-NEXT:                                        operations
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --disable-nontrapping-float-to-int   Disable nontrapping float-to-int
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --disable-nontrapping-float-to-int   Disable nontrapping float-to-int 
 ;; CHECK-NEXT:                                        operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-simd                        Enable SIMD operations and types
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-simd                       Disable SIMD operations and types
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-bulk-memory                 Enable bulk memory operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-bulk-memory                Disable bulk memory operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-bulk-memory-opt             Enable memory.copy and memory.fill
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-bulk-memory-opt            Disable memory.copy and memory.fill
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --enable-call-indirect-overlong      Enable LEB encoding of call-indirect
-;; CHECK-NEXT:                                        (Ignored for compatibility as it has no
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --enable-call-indirect-overlong      Enable LEB encoding of call-indirect 
+;; CHECK-NEXT:                                        (Ignored for compatibility as it has no 
 ;; CHECK-NEXT:                                        effect on Binaryen)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --disable-call-indirect-overlong     Disable LEB encoding of call-indirect
-;; CHECK-NEXT:                                        (Ignored for compatibility as it has no
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --disable-call-indirect-overlong     Disable LEB encoding of call-indirect 
+;; CHECK-NEXT:                                        (Ignored for compatibility as it has no 
 ;; CHECK-NEXT:                                        effect on Binaryen)
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-exception-handling          Enable exception handling operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-exception-handling         Disable exception handling operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-tail-call                   Enable tail call operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-tail-call                  Disable tail call operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-reference-types             Enable reference types
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-reference-types            Disable reference types
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-multivalue                  Enable multivalue functions
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-multivalue                 Disable multivalue functions
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-gc                          Enable garbage collection
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-gc                         Disable garbage collection
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-memory64                    Enable memory64
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-memory64                   Disable memory64
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-relaxed-simd                Enable relaxed SIMD
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-relaxed-simd               Disable relaxed SIMD
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-extended-const              Enable extended const expressions
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-extended-const             Disable extended const expressions
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-strings                     Enable strings
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-strings                    Disable strings
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-multimemory                 Enable multimemory
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-multimemory                Disable multimemory
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-stack-switching             Enable stack switching
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-stack-switching            Disable stack switching
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-shared-everything           Enable shared-everything threads
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-shared-everything          Disable shared-everything threads
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-fp16                        Enable float 16 operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-fp16                       Disable float 16 operations
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --enable-custom-descriptors          Enable custom descriptors (RTTs) and
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --enable-custom-descriptors          Enable custom descriptors (RTTs) and 
 ;; CHECK-NEXT:                                        exact references
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --disable-custom-descriptors         Disable custom descriptors (RTTs) and
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --disable-custom-descriptors         Disable custom descriptors (RTTs) and 
 ;; CHECK-NEXT:                                        exact references
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-multibyte                   Enable multibyte array loads and stores
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-multibyte                  Disable multibyte array loads and stores
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --enable-acquire-release-atomics     Enable acquire/release atomic memory
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --enable-acquire-release-atomics     Enable acquire/release atomic memory 
 ;; CHECK-NEXT:                                        operations
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --disable-acquire-release-atomics    Disable acquire/release atomic memory
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --disable-acquire-release-atomics    Disable acquire/release atomic memory 
 ;; CHECK-NEXT:                                        operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-custom-page-sizes           Enable custom page sizes
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-custom-page-sizes          Disable custom page sizes
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-wide-arithmetic             Enable wide arithmetic
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-wide-arithmetic            Disable wide arithmetic
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-compact-imports             Enable compact import section
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-compact-imports            Disable compact import section
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-relaxed-atomics             Enable relaxed atomic memory operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-relaxed-atomics            Disable relaxed atomic memory operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-typed-function-references   Deprecated compatibility flag
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-typed-function-references  Deprecated compatibility flag
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --no-validation,-n                   Disables validation, assumes inputs are
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --no-validation,-n                   Disables validation, assumes inputs are 
 ;; CHECK-NEXT:                                        correct
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --pass-arg,-pa                       An argument passed along to optimization
-;; CHECK-NEXT:                                        passes being run. Must be in the form
-;; CHECK-NEXT:                                        KEY@VALUE.  If KEY is the name of a pass
-;; CHECK-NEXT:                                        then it applies to the closest instance
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --pass-arg,-pa                       An argument passed along to optimization 
+;; CHECK-NEXT:                                        passes being run. Must be in the form 
+;; CHECK-NEXT:                                        KEY@VALUE.  If KEY is the name of a pass 
+;; CHECK-NEXT:                                        then it applies to the closest instance 
 ;; CHECK-NEXT:                                        of that pass before us. If KEY is not the
 ;; CHECK-NEXT:                                        name of a pass then it is a global option
-;; CHECK-NEXT:                                        that applies to all pass instances that
+;; CHECK-NEXT:                                        that applies to all pass instances that 
 ;; CHECK-NEXT:                                        read it.
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --closed-world,-cw                   Assume code outside of the module does
-;; CHECK-NEXT:                                        not inspect or interact with GC and
-;; CHECK-NEXT:                                        function references, even if they are
-;; CHECK-NEXT:                                        passed out. The outside may hold on to
-;; CHECK-NEXT:                                        them and pass them back in, but not
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --closed-world,-cw                   Assume code outside of the module does 
+;; CHECK-NEXT:                                        not inspect or interact with GC and 
+;; CHECK-NEXT:                                        function references, even if they are 
+;; CHECK-NEXT:                                        passed out. The outside may hold on to 
+;; CHECK-NEXT:                                        them and pass them back in, but not 
 ;; CHECK-NEXT:                                        inspect their contents or call them.
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --preserve-type-order                Preserve the order of types from the
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --preserve-type-order                Preserve the order of types from the 
 ;; CHECK-NEXT:                                        input (useful for debugging and testing)
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --generate-stack-ir                  generate StackIR during writing
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --optimize-stack-ir                  optimize StackIR during writing
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --print-stack-ir                     print StackIR during writing
-;; CHECK-NEXT:
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT: General options:
 ;; CHECK-NEXT: ----------------
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --version                            Output version information and exit
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --help,-h                            Show this help message and exit
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --debug,-d                           Print debug information to stderr
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
diff --git a/test/lit/help/wasm-dis.test b/test/lit/help/wasm-dis.test
index 0f1c7935d85..552286b0128 100644
--- a/test/lit/help/wasm-dis.test
+++ b/test/lit/help/wasm-dis.test
@@ -1,200 +1,200 @@
 ;; RUN: wasm-dis --help | filecheck %s
 ;; CHECK: ================================================================================
 ;; CHECK-NEXT: wasm-dis INFILE
-;; CHECK-NEXT:
-;; CHECK-NEXT: Un-assemble a .wasm (WebAssembly binary format) into a .wat (WebAssembly text
+;; CHECK-EMPTY:
+;; CHECK-NEXT: Un-assemble a .wasm (WebAssembly binary format) into a .wat (WebAssembly text 
 ;; CHECK-NEXT: format)
 ;; CHECK-NEXT: ================================================================================
-;; CHECK-NEXT:
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT: wasm-dis options:
 ;; CHECK-NEXT: -----------------
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --output,-o                          Output file (stdout if not specified)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --source-map,-sm                     Consume source map from the specified
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --source-map,-sm                     Consume source map from the specified 
 ;; CHECK-NEXT:                                        file to add location information
-;; CHECK-NEXT:
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT: Tool options:
 ;; CHECK-NEXT: -------------
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --mvp-features,-mvp                  Disable all non-MVP features
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --all-features,-all                  Enable all features
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --detect-features                    (deprecated - this flag does nothing)
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --quiet,-q                           Emit less verbose output and hide trivial
 ;; CHECK-NEXT:                                        warnings.
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --experimental-poppy                 Parse wast files as Poppy IR for testing
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --experimental-poppy                 Parse wast files as Poppy IR for testing 
 ;; CHECK-NEXT:                                        purposes.
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --emit-module-names                  Emit module names, even if not emitting
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --emit-module-names                  Emit module names, even if not emitting 
 ;; CHECK-NEXT:                                        the rest of the names section.
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-sign-ext                    Enable sign extension operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-sign-ext                   Disable sign extension operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-threads                     Enable atomic operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-threads                    Disable atomic operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-mutable-globals             Enable mutable globals
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-mutable-globals            Disable mutable globals
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --enable-nontrapping-float-to-int    Enable nontrapping float-to-int
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --enable-nontrapping-float-to-int    Enable nontrapping float-to-int 
 ;; CHECK-NEXT:                                        operations
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --disable-nontrapping-float-to-int   Disable nontrapping float-to-int
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --disable-nontrapping-float-to-int   Disable nontrapping float-to-int 
 ;; CHECK-NEXT:                                        operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-simd                        Enable SIMD operations and types
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-simd                       Disable SIMD operations and types
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-bulk-memory                 Enable bulk memory operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-bulk-memory                Disable bulk memory operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-bulk-memory-opt             Enable memory.copy and memory.fill
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-bulk-memory-opt            Disable memory.copy and memory.fill
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --enable-call-indirect-overlong      Enable LEB encoding of call-indirect
-;; CHECK-NEXT:                                        (Ignored for compatibility as it has no
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --enable-call-indirect-overlong      Enable LEB encoding of call-indirect 
+;; CHECK-NEXT:                                        (Ignored for compatibility as it has no 
 ;; CHECK-NEXT:                                        effect on Binaryen)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --disable-call-indirect-overlong     Disable LEB encoding of call-indirect
-;; CHECK-NEXT:                                        (Ignored for compatibility as it has no
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --disable-call-indirect-overlong     Disable LEB encoding of call-indirect 
+;; CHECK-NEXT:                                        (Ignored for compatibility as it has no 
 ;; CHECK-NEXT:                                        effect on Binaryen)
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-exception-handling          Enable exception handling operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-exception-handling         Disable exception handling operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-tail-call                   Enable tail call operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-tail-call                  Disable tail call operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-reference-types             Enable reference types
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-reference-types            Disable reference types
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-multivalue                  Enable multivalue functions
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-multivalue                 Disable multivalue functions
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-gc                          Enable garbage collection
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-gc                         Disable garbage collection
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-memory64                    Enable memory64
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-memory64                   Disable memory64
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-relaxed-simd                Enable relaxed SIMD
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-relaxed-simd               Disable relaxed SIMD
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-extended-const              Enable extended const expressions
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-extended-const             Disable extended const expressions
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-strings                     Enable strings
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-strings                    Disable strings
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-multimemory                 Enable multimemory
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-multimemory                Disable multimemory
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-stack-switching             Enable stack switching
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-stack-switching            Disable stack switching
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-shared-everything           Enable shared-everything threads
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-shared-everything          Disable shared-everything threads
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-fp16                        Enable float 16 operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-fp16                       Disable float 16 operations
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --enable-custom-descriptors          Enable custom descriptors (RTTs) and
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --enable-custom-descriptors          Enable custom descriptors (RTTs) and 
 ;; CHECK-NEXT:                                        exact references
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --disable-custom-descriptors         Disable custom descriptors (RTTs) and
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --disable-custom-descriptors         Disable custom descriptors (RTTs) and 
 ;; CHECK-NEXT:                                        exact references
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-multibyte                   Enable multibyte array loads and stores
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-multibyte                  Disable multibyte array loads and stores
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --enable-acquire-release-atomics     Enable acquire/release atomic memory
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --enable-acquire-release-atomics     Enable acquire/release atomic memory 
 ;; CHECK-NEXT:                                        operations
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --disable-acquire-release-atomics    Disable acquire/release atomic memory
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --disable-acquire-release-atomics    Disable acquire/release atomic memory 
 ;; CHECK-NEXT:                                        operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-custom-page-sizes           Enable custom page sizes
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-custom-page-sizes          Disable custom page sizes
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-wide-arithmetic             Enable wide arithmetic
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-wide-arithmetic            Disable wide arithmetic
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-compact-imports             Enable compact import section
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-compact-imports            Disable compact import section
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-relaxed-atomics             Enable relaxed atomic memory operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-relaxed-atomics            Disable relaxed atomic memory operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-typed-function-references   Deprecated compatibility flag
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-typed-function-references  Deprecated compatibility flag
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --no-validation,-n                   Disables validation, assumes inputs are
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --no-validation,-n                   Disables validation, assumes inputs are 
 ;; CHECK-NEXT:                                        correct
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --pass-arg,-pa                       An argument passed along to optimization
-;; CHECK-NEXT:                                        passes being run. Must be in the form
-;; CHECK-NEXT:                                        KEY@VALUE.  If KEY is the name of a pass
-;; CHECK-NEXT:                                        then it applies to the closest instance
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --pass-arg,-pa                       An argument passed along to optimization 
+;; CHECK-NEXT:                                        passes being run. Must be in the form 
+;; CHECK-NEXT:                                        KEY@VALUE.  If KEY is the name of a pass 
+;; CHECK-NEXT:                                        then it applies to the closest instance 
 ;; CHECK-NEXT:                                        of that pass before us. If KEY is not the
 ;; CHECK-NEXT:                                        name of a pass then it is a global option
-;; CHECK-NEXT:                                        that applies to all pass instances that
+;; CHECK-NEXT:                                        that applies to all pass instances that 
 ;; CHECK-NEXT:                                        read it.
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --closed-world,-cw                   Assume code outside of the module does
-;; CHECK-NEXT:                                        not inspect or interact with GC and
-;; CHECK-NEXT:                                        function references, even if they are
-;; CHECK-NEXT:                                        passed out. The outside may hold on to
-;; CHECK-NEXT:                                        them and pass them back in, but not
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --closed-world,-cw                   Assume code outside of the module does 
+;; CHECK-NEXT:                                        not inspect or interact with GC and 
+;; CHECK-NEXT:                                        function references, even if they are 
+;; CHECK-NEXT:                                        passed out. The outside may hold on to 
+;; CHECK-NEXT:                                        them and pass them back in, but not 
 ;; CHECK-NEXT:                                        inspect their contents or call them.
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --preserve-type-order                Preserve the order of types from the
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --preserve-type-order                Preserve the order of types from the 
 ;; CHECK-NEXT:                                        input (useful for debugging and testing)
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --generate-stack-ir                  generate StackIR during writing
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --optimize-stack-ir                  optimize StackIR during writing
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --print-stack-ir                     print StackIR during writing
-;; CHECK-NEXT:
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT: General options:
 ;; CHECK-NEXT: ----------------
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --version                            Output version information and exit
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --help,-h                            Show this help message and exit
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --debug,-d                           Print debug information to stderr
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
diff --git a/test/lit/help/wasm-emscripten-finalize.test b/test/lit/help/wasm-emscripten-finalize.test
index d1241b49ced..b3a852124e2 100644
--- a/test/lit/help/wasm-emscripten-finalize.test
+++ b/test/lit/help/wasm-emscripten-finalize.test
@@ -1,238 +1,238 @@
 ;; RUN: wasm-emscripten-finalize --help | filecheck %s
 ;; CHECK: ================================================================================
 ;; CHECK-NEXT: wasm-emscripten-finalize INFILE
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT: Performs Emscripten-specific transforms on .wasm files
 ;; CHECK-NEXT: ================================================================================
-;; CHECK-NEXT:
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT: wasm-emscripten-finalize options:
 ;; CHECK-NEXT: ---------------------------------
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --output,-o                          Output file
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --debuginfo,-g                       Emit names section in wasm binary (or
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --debuginfo,-g                       Emit names section in wasm binary (or 
 ;; CHECK-NEXT:                                        full debuginfo in wast)
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --dwarf                              Update DWARF debug info
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --emit-text,-S                       Emit text instead of binary for the
-;; CHECK-NEXT:                                        output file. In this mode if no output
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --emit-text,-S                       Emit text instead of binary for the 
+;; CHECK-NEXT:                                        output file. In this mode if no output 
 ;; CHECK-NEXT:                                        file is specified, we write to stdout.
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --side-module                        Input is an emscripten side module
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --input-source-map,-ism              Consume source map from the specified
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --input-source-map,-ism              Consume source map from the specified 
 ;; CHECK-NEXT:                                        file
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --bigint,-bi                         Assume JS will use wasm/JS BigInt
-;; CHECK-NEXT:                                        integration, so wasm i64s will turn into
-;; CHECK-NEXT:                                        JS BigInts, and there is no need for any
-;; CHECK-NEXT:                                        legalization at all (not even minimal
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --bigint,-bi                         Assume JS will use wasm/JS BigInt 
+;; CHECK-NEXT:                                        integration, so wasm i64s will turn into 
+;; CHECK-NEXT:                                        JS BigInts, and there is no need for any 
+;; CHECK-NEXT:                                        legalization at all (not even minimal 
 ;; CHECK-NEXT:                                        legalization of dynCalls)
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --output-source-map,-osm             Emit source map to the specified file
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --output-source-map-url,-osu         Emit specified string as source map URL
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --check-stack-overflow               Check for stack overflows every time the
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --check-stack-overflow               Check for stack overflows every time the 
 ;; CHECK-NEXT:                                        stack is extended
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --standalone-wasm                    Emit a wasm file that does not depend on
-;; CHECK-NEXT:                                        JS, as much as possible, using wasi and
-;; CHECK-NEXT:                                        other standard conventions etc. where
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --standalone-wasm                    Emit a wasm file that does not depend on 
+;; CHECK-NEXT:                                        JS, as much as possible, using wasi and 
+;; CHECK-NEXT:                                        other standard conventions etc. where 
 ;; CHECK-NEXT:                                        possible
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --minimize-wasm-changes              Modify the wasm as little as possible.
-;; CHECK-NEXT:                                        This is useful during development as we
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --minimize-wasm-changes              Modify the wasm as little as possible. 
+;; CHECK-NEXT:                                        This is useful during development as we 
 ;; CHECK-NEXT:                                        reduce the number of changes to the wasm,
-;; CHECK-NEXT:                                        as it lets emscripten control how much
+;; CHECK-NEXT:                                        as it lets emscripten control how much 
 ;; CHECK-NEXT:                                        modifications to do.
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --no-dyncalls
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --dyncalls-i64
-;; CHECK-NEXT:
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --no-dyncalls                        
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --dyncalls-i64                       
+;; CHECK-EMPTY:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT: Tool options:
 ;; CHECK-NEXT: -------------
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --mvp-features,-mvp                  Disable all non-MVP features
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --all-features,-all                  Enable all features
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --detect-features                    (deprecated - this flag does nothing)
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --quiet,-q                           Emit less verbose output and hide trivial
 ;; CHECK-NEXT:                                        warnings.
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --experimental-poppy                 Parse wast files as Poppy IR for testing
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --experimental-poppy                 Parse wast files as Poppy IR for testing 
 ;; CHECK-NEXT:                                        purposes.
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --emit-module-names                  Emit module names, even if not emitting
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --emit-module-names                  Emit module names, even if not emitting 
 ;; CHECK-NEXT:                                        the rest of the names section.
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-sign-ext                    Enable sign extension operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-sign-ext                   Disable sign extension operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-threads                     Enable atomic operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-threads                    Disable atomic operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-mutable-globals             Enable mutable globals
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-mutable-globals            Disable mutable globals
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --enable-nontrapping-float-to-int    Enable nontrapping float-to-int
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --enable-nontrapping-float-to-int    Enable nontrapping float-to-int 
 ;; CHECK-NEXT:                                        operations
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --disable-nontrapping-float-to-int   Disable nontrapping float-to-int
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --disable-nontrapping-float-to-int   Disable nontrapping float-to-int 
 ;; CHECK-NEXT:                                        operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-simd                        Enable SIMD operations and types
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-simd                       Disable SIMD operations and types
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-bulk-memory                 Enable bulk memory operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-bulk-memory                Disable bulk memory operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-bulk-memory-opt             Enable memory.copy and memory.fill
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-bulk-memory-opt            Disable memory.copy and memory.fill
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --enable-call-indirect-overlong      Enable LEB encoding of call-indirect
-;; CHECK-NEXT:                                        (Ignored for compatibility as it has no
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --enable-call-indirect-overlong      Enable LEB encoding of call-indirect 
+;; CHECK-NEXT:                                        (Ignored for compatibility as it has no 
 ;; CHECK-NEXT:                                        effect on Binaryen)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --disable-call-indirect-overlong     Disable LEB encoding of call-indirect
-;; CHECK-NEXT:                                        (Ignored for compatibility as it has no
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --disable-call-indirect-overlong     Disable LEB encoding of call-indirect 
+;; CHECK-NEXT:                                        (Ignored for compatibility as it has no 
 ;; CHECK-NEXT:                                        effect on Binaryen)
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-exception-handling          Enable exception handling operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-exception-handling         Disable exception handling operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-tail-call                   Enable tail call operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-tail-call                  Disable tail call operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-reference-types             Enable reference types
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-reference-types            Disable reference types
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-multivalue                  Enable multivalue functions
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-multivalue                 Disable multivalue functions
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-gc                          Enable garbage collection
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-gc                         Disable garbage collection
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-memory64                    Enable memory64
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-memory64                   Disable memory64
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-relaxed-simd                Enable relaxed SIMD
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-relaxed-simd               Disable relaxed SIMD
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-extended-const              Enable extended const expressions
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-extended-const             Disable extended const expressions
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-strings                     Enable strings
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-strings                    Disable strings
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-multimemory                 Enable multimemory
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-multimemory                Disable multimemory
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-stack-switching             Enable stack switching
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-stack-switching            Disable stack switching
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-shared-everything           Enable shared-everything threads
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-shared-everything          Disable shared-everything threads
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-fp16                        Enable float 16 operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-fp16                       Disable float 16 operations
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --enable-custom-descriptors          Enable custom descriptors (RTTs) and
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --enable-custom-descriptors          Enable custom descriptors (RTTs) and 
 ;; CHECK-NEXT:                                        exact references
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --disable-custom-descriptors         Disable custom descriptors (RTTs) and
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --disable-custom-descriptors         Disable custom descriptors (RTTs) and 
 ;; CHECK-NEXT:                                        exact references
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-multibyte                   Enable multibyte array loads and stores
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-multibyte                  Disable multibyte array loads and stores
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --enable-acquire-release-atomics     Enable acquire/release atomic memory
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --enable-acquire-release-atomics     Enable acquire/release atomic memory 
 ;; CHECK-NEXT:                                        operations
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --disable-acquire-release-atomics    Disable acquire/release atomic memory
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --disable-acquire-release-atomics    Disable acquire/release atomic memory 
 ;; CHECK-NEXT:                                        operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-custom-page-sizes           Enable custom page sizes
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-custom-page-sizes          Disable custom page sizes
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-wide-arithmetic             Enable wide arithmetic
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-wide-arithmetic            Disable wide arithmetic
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-compact-imports             Enable compact import section
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-compact-imports            Disable compact import section
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-relaxed-atomics             Enable relaxed atomic memory operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-relaxed-atomics            Disable relaxed atomic memory operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-typed-function-references   Deprecated compatibility flag
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-typed-function-references  Deprecated compatibility flag
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --no-validation,-n                   Disables validation, assumes inputs are
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --no-validation,-n                   Disables validation, assumes inputs are 
 ;; CHECK-NEXT:                                        correct
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --pass-arg,-pa                       An argument passed along to optimization
-;; CHECK-NEXT:                                        passes being run. Must be in the form
-;; CHECK-NEXT:                                        KEY@VALUE.  If KEY is the name of a pass
-;; CHECK-NEXT:                                        then it applies to the closest instance
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --pass-arg,-pa                       An argument passed along to optimization 
+;; CHECK-NEXT:                                        passes being run. Must be in the form 
+;; CHECK-NEXT:                                        KEY@VALUE.  If KEY is the name of a pass 
+;; CHECK-NEXT:                                        then it applies to the closest instance 
 ;; CHECK-NEXT:                                        of that pass before us. If KEY is not the
 ;; CHECK-NEXT:                                        name of a pass then it is a global option
-;; CHECK-NEXT:                                        that applies to all pass instances that
+;; CHECK-NEXT:                                        that applies to all pass instances that 
 ;; CHECK-NEXT:                                        read it.
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --closed-world,-cw                   Assume code outside of the module does
-;; CHECK-NEXT:                                        not inspect or interact with GC and
-;; CHECK-NEXT:                                        function references, even if they are
-;; CHECK-NEXT:                                        passed out. The outside may hold on to
-;; CHECK-NEXT:                                        them and pass them back in, but not
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --closed-world,-cw                   Assume code outside of the module does 
+;; CHECK-NEXT:                                        not inspect or interact with GC and 
+;; CHECK-NEXT:                                        function references, even if they are 
+;; CHECK-NEXT:                                        passed out. The outside may hold on to 
+;; CHECK-NEXT:                                        them and pass them back in, but not 
 ;; CHECK-NEXT:                                        inspect their contents or call them.
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --preserve-type-order                Preserve the order of types from the
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --preserve-type-order                Preserve the order of types from the 
 ;; CHECK-NEXT:                                        input (useful for debugging and testing)
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --generate-stack-ir                  generate StackIR during writing
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --optimize-stack-ir                  optimize StackIR during writing
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --print-stack-ir                     print StackIR during writing
-;; CHECK-NEXT:
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT: General options:
 ;; CHECK-NEXT: ----------------
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --version                            Output version information and exit
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --help,-h                            Show this help message and exit
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --debug,-d                           Print debug information to stderr
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
diff --git a/test/lit/help/wasm-fuzz-types.test b/test/lit/help/wasm-fuzz-types.test
index 5bd5974fd3c..be2ac60f024 100644
--- a/test/lit/help/wasm-fuzz-types.test
+++ b/test/lit/help/wasm-fuzz-types.test
@@ -1,25 +1,25 @@
 ;; RUN: wasm-fuzz-types --help | filecheck %s
 ;; CHECK: ================================================================================
 ;; CHECK-NEXT: wasm-fuzz-types
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT: Fuzz type construction, canonicalization, and operations
 ;; CHECK-NEXT: ================================================================================
-;; CHECK-NEXT:
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT: wasm-fuzz-types options:
 ;; CHECK-NEXT: ------------------------
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --seed       Run a single workload generated by the given seed
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --verbose,-v Print extra information
-;; CHECK-NEXT:
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT: General options:
 ;; CHECK-NEXT: ----------------
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --version    Output version information and exit
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --help,-h    Show this help message and exit
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --debug,-d   Print debug information to stderr
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
diff --git a/test/lit/help/wasm-merge.test b/test/lit/help/wasm-merge.test
index c68d11f7324..f25743a8062 100644
--- a/test/lit/help/wasm-merge.test
+++ b/test/lit/help/wasm-merge.test
@@ -1,237 +1,237 @@
 ;; RUN: wasm-merge --help | filecheck %s
 ;; CHECK: ================================================================================
 ;; CHECK-NEXT: wasm-merge INFILE1 NAME1 INFILE2 NAME2 [..]
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT: Merge wasm files into one.
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT: For example,
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   wasm-merge foo.wasm foo bar.wasm bar -o merged.wasm
-;; CHECK-NEXT:
-;; CHECK-NEXT: will read foo.wasm and bar.wasm, with names 'foo' and 'bar' respectively, so if
-;; CHECK-NEXT: the second imports from 'foo', we will see that as an import from the first
+;; CHECK-EMPTY:
+;; CHECK-NEXT: will read foo.wasm and bar.wasm, with names 'foo' and 'bar' respectively, so if 
+;; CHECK-NEXT: the second imports from 'foo', we will see that as an import from the first 
 ;; CHECK-NEXT: module after the merge. The merged output will be written to merged.wasm.
-;; CHECK-NEXT:
-;; CHECK-NEXT: Note that filenames and modules names are interleaved (which is hopefully less
+;; CHECK-EMPTY:
+;; CHECK-NEXT: Note that filenames and modules names are interleaved (which is hopefully less 
 ;; CHECK-NEXT: confusing).
-;; CHECK-NEXT:
-;; CHECK-NEXT: Input source maps can be specified by adding an -ism option right after the
+;; CHECK-EMPTY:
+;; CHECK-NEXT: Input source maps can be specified by adding an -ism option right after the 
 ;; CHECK-NEXT: module name:
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   wasm-merge foo.wasm foo -ism foo.wasm.map ...
 ;; CHECK-NEXT: ================================================================================
-;; CHECK-NEXT:
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT: wasm-merge options:
 ;; CHECK-NEXT: -------------------
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --output,-o                          Output file
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --input-source-map,-ism              Consume source maps from the specified
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --input-source-map,-ism              Consume source maps from the specified 
 ;; CHECK-NEXT:                                        files
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --output-source-map,-osm             Emit source map to the specified file
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --output-source-map-url,-osu         Emit specified string as source map URL
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --output-manifest                    Write a wasm-split manifest to the
-;; CHECK-NEXT:                                        specified file. This manifest can be
-;; CHECK-NEXT:                                        given to wasm-split to split the merged
-;; CHECK-NEXT:                                        module along the lines of the original
-;; CHECK-NEXT:                                        modules. Implies --debuginfo to preserve
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --output-manifest                    Write a wasm-split manifest to the 
+;; CHECK-NEXT:                                        specified file. This manifest can be 
+;; CHECK-NEXT:                                        given to wasm-split to split the merged 
+;; CHECK-NEXT:                                        module along the lines of the original 
+;; CHECK-NEXT:                                        modules. Implies --debuginfo to preserve 
 ;; CHECK-NEXT:                                        function names in the output module.
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --rename-export-conflicts,-rec       Rename exports to avoid conflicts (rather
 ;; CHECK-NEXT:                                        than error)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --skip-export-conflicts,-sec         Skip exports that conflict with previous
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --skip-export-conflicts,-sec         Skip exports that conflict with previous 
 ;; CHECK-NEXT:                                        ones
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --emit-text,-S                       Emit text instead of binary for the
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --emit-text,-S                       Emit text instead of binary for the 
 ;; CHECK-NEXT:                                        output file
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --debuginfo,-g                       Emit names section and debug info
-;; CHECK-NEXT:
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT: Tool options:
 ;; CHECK-NEXT: -------------
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --mvp-features,-mvp                  Disable all non-MVP features
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --all-features,-all                  Enable all features
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --detect-features                    (deprecated - this flag does nothing)
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --quiet,-q                           Emit less verbose output and hide trivial
 ;; CHECK-NEXT:                                        warnings.
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --experimental-poppy                 Parse wast files as Poppy IR for testing
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --experimental-poppy                 Parse wast files as Poppy IR for testing 
 ;; CHECK-NEXT:                                        purposes.
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --emit-module-names                  Emit module names, even if not emitting
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --emit-module-names                  Emit module names, even if not emitting 
 ;; CHECK-NEXT:                                        the rest of the names section.
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-sign-ext                    Enable sign extension operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-sign-ext                   Disable sign extension operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-threads                     Enable atomic operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-threads                    Disable atomic operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-mutable-globals             Enable mutable globals
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-mutable-globals            Disable mutable globals
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --enable-nontrapping-float-to-int    Enable nontrapping float-to-int
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --enable-nontrapping-float-to-int    Enable nontrapping float-to-int 
 ;; CHECK-NEXT:                                        operations
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --disable-nontrapping-float-to-int   Disable nontrapping float-to-int
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --disable-nontrapping-float-to-int   Disable nontrapping float-to-int 
 ;; CHECK-NEXT:                                        operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-simd                        Enable SIMD operations and types
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-simd                       Disable SIMD operations and types
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-bulk-memory                 Enable bulk memory operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-bulk-memory                Disable bulk memory operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-bulk-memory-opt             Enable memory.copy and memory.fill
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-bulk-memory-opt            Disable memory.copy and memory.fill
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --enable-call-indirect-overlong      Enable LEB encoding of call-indirect
-;; CHECK-NEXT:                                        (Ignored for compatibility as it has no
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --enable-call-indirect-overlong      Enable LEB encoding of call-indirect 
+;; CHECK-NEXT:                                        (Ignored for compatibility as it has no 
 ;; CHECK-NEXT:                                        effect on Binaryen)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --disable-call-indirect-overlong     Disable LEB encoding of call-indirect
-;; CHECK-NEXT:                                        (Ignored for compatibility as it has no
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --disable-call-indirect-overlong     Disable LEB encoding of call-indirect 
+;; CHECK-NEXT:                                        (Ignored for compatibility as it has no 
 ;; CHECK-NEXT:                                        effect on Binaryen)
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-exception-handling          Enable exception handling operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-exception-handling         Disable exception handling operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-tail-call                   Enable tail call operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-tail-call                  Disable tail call operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-reference-types             Enable reference types
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-reference-types            Disable reference types
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-multivalue                  Enable multivalue functions
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-multivalue                 Disable multivalue functions
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-gc                          Enable garbage collection
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-gc                         Disable garbage collection
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-memory64                    Enable memory64
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-memory64                   Disable memory64
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-relaxed-simd                Enable relaxed SIMD
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-relaxed-simd               Disable relaxed SIMD
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-extended-const              Enable extended const expressions
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-extended-const             Disable extended const expressions
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-strings                     Enable strings
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-strings                    Disable strings
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-multimemory                 Enable multimemory
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-multimemory                Disable multimemory
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-stack-switching             Enable stack switching
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-stack-switching            Disable stack switching
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-shared-everything           Enable shared-everything threads
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-shared-everything          Disable shared-everything threads
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-fp16                        Enable float 16 operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-fp16                       Disable float 16 operations
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --enable-custom-descriptors          Enable custom descriptors (RTTs) and
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --enable-custom-descriptors          Enable custom descriptors (RTTs) and 
 ;; CHECK-NEXT:                                        exact references
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --disable-custom-descriptors         Disable custom descriptors (RTTs) and
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --disable-custom-descriptors         Disable custom descriptors (RTTs) and 
 ;; CHECK-NEXT:                                        exact references
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-multibyte                   Enable multibyte array loads and stores
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-multibyte                  Disable multibyte array loads and stores
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --enable-acquire-release-atomics     Enable acquire/release atomic memory
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --enable-acquire-release-atomics     Enable acquire/release atomic memory 
 ;; CHECK-NEXT:                                        operations
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --disable-acquire-release-atomics    Disable acquire/release atomic memory
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --disable-acquire-release-atomics    Disable acquire/release atomic memory 
 ;; CHECK-NEXT:                                        operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-custom-page-sizes           Enable custom page sizes
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-custom-page-sizes          Disable custom page sizes
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-wide-arithmetic             Enable wide arithmetic
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-wide-arithmetic            Disable wide arithmetic
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-compact-imports             Enable compact import section
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-compact-imports            Disable compact import section
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-relaxed-atomics             Enable relaxed atomic memory operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-relaxed-atomics            Disable relaxed atomic memory operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-typed-function-references   Deprecated compatibility flag
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-typed-function-references  Deprecated compatibility flag
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --no-validation,-n                   Disables validation, assumes inputs are
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --no-validation,-n                   Disables validation, assumes inputs are 
 ;; CHECK-NEXT:                                        correct
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --pass-arg,-pa                       An argument passed along to optimization
-;; CHECK-NEXT:                                        passes being run. Must be in the form
-;; CHECK-NEXT:                                        KEY@VALUE.  If KEY is the name of a pass
-;; CHECK-NEXT:                                        then it applies to the closest instance
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --pass-arg,-pa                       An argument passed along to optimization 
+;; CHECK-NEXT:                                        passes being run. Must be in the form 
+;; CHECK-NEXT:                                        KEY@VALUE.  If KEY is the name of a pass 
+;; CHECK-NEXT:                                        then it applies to the closest instance 
 ;; CHECK-NEXT:                                        of that pass before us. If KEY is not the
 ;; CHECK-NEXT:                                        name of a pass then it is a global option
-;; CHECK-NEXT:                                        that applies to all pass instances that
+;; CHECK-NEXT:                                        that applies to all pass instances that 
 ;; CHECK-NEXT:                                        read it.
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --closed-world,-cw                   Assume code outside of the module does
-;; CHECK-NEXT:                                        not inspect or interact with GC and
-;; CHECK-NEXT:                                        function references, even if they are
-;; CHECK-NEXT:                                        passed out. The outside may hold on to
-;; CHECK-NEXT:                                        them and pass them back in, but not
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --closed-world,-cw                   Assume code outside of the module does 
+;; CHECK-NEXT:                                        not inspect or interact with GC and 
+;; CHECK-NEXT:                                        function references, even if they are 
+;; CHECK-NEXT:                                        passed out. The outside may hold on to 
+;; CHECK-NEXT:                                        them and pass them back in, but not 
 ;; CHECK-NEXT:                                        inspect their contents or call them.
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --preserve-type-order                Preserve the order of types from the
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --preserve-type-order                Preserve the order of types from the 
 ;; CHECK-NEXT:                                        input (useful for debugging and testing)
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --generate-stack-ir                  generate StackIR during writing
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --optimize-stack-ir                  optimize StackIR during writing
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --print-stack-ir                     print StackIR during writing
-;; CHECK-NEXT:
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT: General options:
 ;; CHECK-NEXT: ----------------
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --version                            Output version information and exit
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --help,-h                            Show this help message and exit
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --debug,-d                           Print debug information to stderr
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
diff --git a/test/lit/help/wasm-metadce.test b/test/lit/help/wasm-metadce.test
index 5e93a909c0f..bd12e989573 100644
--- a/test/lit/help/wasm-metadce.test
+++ b/test/lit/help/wasm-metadce.test
@@ -1,25 +1,25 @@
 ;; RUN: wasm-metadce --help | filecheck %s
 ;; CHECK: ================================================================================
 ;; CHECK-NEXT: wasm-metadce INFILE
-;; CHECK-NEXT:
-;; CHECK-NEXT: This tool performs dead code elimination (DCE) on a larger space that the wasm
-;; CHECK-NEXT: module is just a part of. For example, if you have JS and wasm that are
+;; CHECK-EMPTY:
+;; CHECK-NEXT: This tool performs dead code elimination (DCE) on a larger space that the wasm 
+;; CHECK-NEXT: module is just a part of. For example, if you have JS and wasm that are 
 ;; CHECK-NEXT: connected, this can DCE the combined graph. By doing so, it is able to eliminate
 ;; CHECK-NEXT: wasm module exports, which otherwise regular optimizations cannot.
-;; CHECK-NEXT:
-;; CHECK-NEXT: This tool receives a representation of the reachability graph that the wasm
-;; CHECK-NEXT: module resides in, which contains abstract nodes and connections showing what
-;; CHECK-NEXT: they reach. Some of those nodes can represent the wasm module's imports and
-;; CHECK-NEXT: exports. The tool then completes the graph by adding the internal parts of the
+;; CHECK-EMPTY:
+;; CHECK-NEXT: This tool receives a representation of the reachability graph that the wasm 
+;; CHECK-NEXT: module resides in, which contains abstract nodes and connections showing what 
+;; CHECK-NEXT: they reach. Some of those nodes can represent the wasm module's imports and 
+;; CHECK-NEXT: exports. The tool then completes the graph by adding the internal parts of the 
 ;; CHECK-NEXT: module, and does DCE on the entire thing.
-;; CHECK-NEXT:
-;; CHECK-NEXT: This tool will output a wasm module with dead code eliminated, and metadata
+;; CHECK-EMPTY:
+;; CHECK-NEXT: This tool will output a wasm module with dead code eliminated, and metadata 
 ;; CHECK-NEXT: describing the things in the rest of the graph that can be eliminated as well.
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT: The graph description file should represent the graph in the following JSON-like
-;; CHECK-NEXT: notation (note, this is not true JSON, things like comments, escaping,
+;; CHECK-NEXT: notation (note, this is not true JSON, things like comments, escaping, 
 ;; CHECK-NEXT: single-quotes, etc. are not supported):
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   [
 ;; CHECK-NEXT:     {
 ;; CHECK-NEXT:       "name": "entity1",
@@ -40,860 +40,860 @@
 ;; CHECK-NEXT:       "import": ["module", "import1"]
 ;; CHECK-NEXT:     },
 ;; CHECK-NEXT:   ]
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT: Each entity has a name and an optional list of the other entities it reaches. It
-;; CHECK-NEXT: can also be marked as a root, export (with the export string), or import (with
-;; CHECK-NEXT: the module and import strings). DCE then computes what is reachable from the
+;; CHECK-NEXT: can also be marked as a root, export (with the export string), or import (with 
+;; CHECK-NEXT: the module and import strings). DCE then computes what is reachable from the 
 ;; CHECK-NEXT: roots.
 ;; CHECK-NEXT: ================================================================================
-;; CHECK-NEXT:
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT: wasm-opt options:
 ;; CHECK-NEXT: -----------------
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --output,-o                                   Output file
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --input-source-map,-ism                       Consume source map from the
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --input-source-map,-ism                       Consume source map from the 
 ;; CHECK-NEXT:                                                 specified file
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --output-source-map,-osm                      Emit source map to the specified
 ;; CHECK-NEXT:                                                 file
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --output-source-map-url,-osu                  Emit specified string as source
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --output-source-map-url,-osu                  Emit specified string as source 
 ;; CHECK-NEXT:                                                 map URL
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --emit-text,-S                                Emit text instead of binary for
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --emit-text,-S                                Emit text instead of binary for 
 ;; CHECK-NEXT:                                                 the output file
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --debuginfo,-g                                Emit names section and debug
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --debuginfo,-g                                Emit names section and debug 
 ;; CHECK-NEXT:                                                 info
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --graph-file,-f                               Filename of the graph
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --graph-file,-f                               Filename of the graph 
 ;; CHECK-NEXT:                                                 description file
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --dump,-d                                     Dump the combined graph file
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --dump,-d                                     Dump the combined graph file 
 ;; CHECK-NEXT:                                                 (useful for debugging)
-;; CHECK-NEXT:
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT: Optimization passes:
 ;; CHECK-NEXT: --------------------
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --abstract-type-refining                      refine and merge abstract
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --abstract-type-refining                      refine and merge abstract 
 ;; CHECK-NEXT:                                                 (never-created) types
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --alignment-lowering                          lower unaligned loads and stores
 ;; CHECK-NEXT:                                                 to smaller aligned ones
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --asyncify                                    async/await style transform,
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --asyncify                                    async/await style transform, 
 ;; CHECK-NEXT:                                                 allowing pausing and resuming
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --avoid-reinterprets                          Tries to avoid reinterpret
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --avoid-reinterprets                          Tries to avoid reinterpret 
 ;; CHECK-NEXT:                                                 operations via more loads
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --cfp                                         propagate constant struct field
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --cfp                                         propagate constant struct field 
 ;; CHECK-NEXT:                                                 values
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --cfp-reftest                                 propagate constant struct field
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --cfp-reftest                                 propagate constant struct field 
 ;; CHECK-NEXT:                                                 values, using ref.test
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --coalesce-locals                             reduce # of locals by coalescing
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --coalesce-locals-learning                    reduce # of locals by coalescing
 ;; CHECK-NEXT:                                                 and learning
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --code-folding                                fold code, merging duplicates
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --code-pushing                                push code forward, potentially
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --code-pushing                                push code forward, potentially 
 ;; CHECK-NEXT:                                                 making it not always execute
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --const-hoisting                              hoist repeated constants to a
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --const-hoisting                              hoist repeated constants to a 
 ;; CHECK-NEXT:                                                 local
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --constraint-analysis                         finds and uses mathematical
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --constraint-analysis                         finds and uses mathematical 
 ;; CHECK-NEXT:                                                 constraints on locals
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --dae                                         removes arguments to calls in an
 ;; CHECK-NEXT:                                                 lto-like manner
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --dae-optimizing                              removes arguments to calls in an
-;; CHECK-NEXT:                                                 lto-like manner, and optimizes
+;; CHECK-NEXT:                                                 lto-like manner, and optimizes 
 ;; CHECK-NEXT:                                                 where we removed
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --dae2                                        Experimental reimplementation of
 ;; CHECK-NEXT:                                                 DAE
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --dce                                         removes unreachable code
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --dealign                                     forces all loads and stores to
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --dealign                                     forces all loads and stores to 
 ;; CHECK-NEXT:                                                 have alignment 1
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --denan                                       instrument the wasm to convert
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --denan                                       instrument the wasm to convert 
 ;; CHECK-NEXT:                                                 NaNs into 0 at runtime
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --dfo                                         optimizes using the DataFlow SSA
 ;; CHECK-NEXT:                                                 IR
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --directize                                   turns indirect calls into direct
 ;; CHECK-NEXT:                                                 ones
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --discard-global-effects                      discards global effect info
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --duplicate-function-elimination              removes duplicate functions
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --duplicate-import-elimination                removes duplicate imports
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --dwarfdump                                   dump DWARF debug info sections
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --dwarfdump                                   dump DWARF debug info sections 
 ;; CHECK-NEXT:                                                 from the read binary
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --emit-target-features                        emit the target features section
 ;; CHECK-NEXT:                                                 in the output
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --enclose-world                               modify the wasm (destructively)
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --enclose-world                               modify the wasm (destructively) 
 ;; CHECK-NEXT:                                                 for closed-world
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --extract-function                            leaves just one function (useful
 ;; CHECK-NEXT:                                                 for debugging)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --extract-function-index                      leaves just one function
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --extract-function-index                      leaves just one function 
 ;; CHECK-NEXT:                                                 selected by index
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --flatten                                     flattens out code, removing
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --flatten                                     flattens out code, removing 
 ;; CHECK-NEXT:                                                 nesting
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --fpcast-emu                                  emulates function pointer casts,
-;; CHECK-NEXT:                                                 allowing incorrect indirect
+;; CHECK-NEXT:                                                 allowing incorrect indirect 
 ;; CHECK-NEXT:                                                 calls to (sometimes) work
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --func-metrics                                reports function metrics
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --generate-dyncalls                           generate dynCall functions used
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --generate-dyncalls                           generate dynCall functions used 
 ;; CHECK-NEXT:                                                 by emscripten ABI
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --generate-global-effects                     generate global effect info
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --generate-global-effects                     generate global effect info 
 ;; CHECK-NEXT:                                                 (helps later passes)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --generate-i64-dyncalls                       generate dynCall functions used
-;; CHECK-NEXT:                                                 by emscripten ABI, but only for
-;; CHECK-NEXT:                                                 functions with i64 in their
-;; CHECK-NEXT:                                                 signature (which cannot be
-;; CHECK-NEXT:                                                 invoked via the wasm table
-;; CHECK-NEXT:                                                 without JavaScript BigInt
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --generate-i64-dyncalls                       generate dynCall functions used 
+;; CHECK-NEXT:                                                 by emscripten ABI, but only for 
+;; CHECK-NEXT:                                                 functions with i64 in their 
+;; CHECK-NEXT:                                                 signature (which cannot be 
+;; CHECK-NEXT:                                                 invoked via the wasm table 
+;; CHECK-NEXT:                                                 without JavaScript BigInt 
 ;; CHECK-NEXT:                                                 support).
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --global-refining                             refine the types of globals
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --gsi                                         globally optimize struct values
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --gsi-desc-cast                               globally optimize struct values,
 ;; CHECK-NEXT:                                                 also emitting ref.cast_desc_eq
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --gto                                         globally optimize GC types
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --gufa                                        Grand Unified Flow Analysis:
-;; CHECK-NEXT:                                                 optimize the entire program
-;; CHECK-NEXT:                                                 using information about what
-;; CHECK-NEXT:                                                 content can actually appear in
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --gufa                                        Grand Unified Flow Analysis: 
+;; CHECK-NEXT:                                                 optimize the entire program 
+;; CHECK-NEXT:                                                 using information about what 
+;; CHECK-NEXT:                                                 content can actually appear in 
 ;; CHECK-NEXT:                                                 each location
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --gufa-cast-all                               GUFA plus add casts for all
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --gufa-cast-all                               GUFA plus add casts for all 
 ;; CHECK-NEXT:                                                 inferences
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --gufa-optimizing                             GUFA plus local optimizations in
 ;; CHECK-NEXT:                                                 functions we modified
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --heap-store-optimization                     optimize heap (GC) stores
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --heap2local                                  replace GC allocations with
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --heap2local                                  replace GC allocations with 
 ;; CHECK-NEXT:                                                 locals
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --i64-to-i32-lowering                         lower all uses of i64s to use
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --i64-to-i32-lowering                         lower all uses of i64s to use 
 ;; CHECK-NEXT:                                                 i32s instead
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --inline-main                                 inline __original_main into main
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --inlining                                    inline functions (you probably
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --inlining                                    inline functions (you probably 
 ;; CHECK-NEXT:                                                 want inlining-optimizing)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --inlining-optimizing                         inline functions and optimizes
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --inlining-optimizing                         inline functions and optimizes 
 ;; CHECK-NEXT:                                                 where we inlined
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --instrument-branch-hints                     instrument branch hints so we
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --instrument-branch-hints                     instrument branch hints so we 
 ;; CHECK-NEXT:                                                 can see which guessed right
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --instrument-locals                           instrument the build with code
-;; CHECK-NEXT:                                                 to intercept all loads and
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --instrument-locals                           instrument the build with code 
+;; CHECK-NEXT:                                                 to intercept all loads and 
 ;; CHECK-NEXT:                                                 stores
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --instrument-memory                           instrument the build with code
-;; CHECK-NEXT:                                                 to intercept all loads and
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --instrument-memory                           instrument the build with code 
+;; CHECK-NEXT:                                                 to intercept all loads and 
 ;; CHECK-NEXT:                                                 stores
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --intrinsic-lowering                          lower away binaryen intrinsics
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --legalize-and-prune-js-interface             legalizes the import/export
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --legalize-and-prune-js-interface             legalizes the import/export 
 ;; CHECK-NEXT:                                                 boundary and prunes when needed
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --legalize-js-interface                       legalizes i64 types on the
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --legalize-js-interface                       legalizes i64 types on the 
 ;; CHECK-NEXT:                                                 import/export boundary
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --licm                                        loop invariant code motion
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --limit-segments                              attempt to merge segments to fit
 ;; CHECK-NEXT:                                                 within web limits
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --llvm-memory-copy-fill-lowering              Lower memory.copy and
-;; CHECK-NEXT:                                                 memory.fill to wasm mvp and
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --llvm-memory-copy-fill-lowering              Lower memory.copy and 
+;; CHECK-NEXT:                                                 memory.fill to wasm mvp and 
 ;; CHECK-NEXT:                                                 disable the bulk-memory feature.
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --llvm-nontrapping-fptoint-lowering           lower nontrapping float-to-int
-;; CHECK-NEXT:                                                 operations to wasm mvp and
-;; CHECK-NEXT:                                                 disable the nontrapping fptoint
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --llvm-nontrapping-fptoint-lowering           lower nontrapping float-to-int 
+;; CHECK-NEXT:                                                 operations to wasm mvp and 
+;; CHECK-NEXT:                                                 disable the nontrapping fptoint 
 ;; CHECK-NEXT:                                                 feature
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --local-cse                                   common subexpression elimination
 ;; CHECK-NEXT:                                                 inside basic blocks
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --local-subtyping                             apply more specific subtypes to
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --local-subtyping                             apply more specific subtypes to 
 ;; CHECK-NEXT:                                                 locals where possible
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --log-execution                               instrument the build with
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --log-execution                               instrument the build with 
 ;; CHECK-NEXT:                                                 logging of where execution goes
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --make-shared-objects                         Make structs and arrays shared
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --make-shared-objects                         Make structs and arrays shared 
 ;; CHECK-NEXT:                                                 and functions unshared
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --mark-js-called                              mark js called functions (using
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --mark-js-called                              mark js called functions (using 
 ;; CHECK-NEXT:                                                 configureAll) as doing so
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --memory-packing                              packs memory into separate
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --memory-packing                              packs memory into separate 
 ;; CHECK-NEXT:                                                 segments, skipping zeros
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --memory64-lowering                           lower loads and stores to a
-;; CHECK-NEXT:                                                 64-bit memory to instead use a
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --memory64-lowering                           lower loads and stores to a 
+;; CHECK-NEXT:                                                 64-bit memory to instead use a 
 ;; CHECK-NEXT:                                                 32-bit one
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --merge-blocks                                merges blocks to their parents
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --merge-j2cl-itables                          Merges itable structures into
-;; CHECK-NEXT:                                                 vtables to make types more
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --merge-j2cl-itables                          Merges itable structures into 
+;; CHECK-NEXT:                                                 vtables to make types more 
 ;; CHECK-NEXT:                                                 compact
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --merge-locals                                merges locals when beneficial
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --merge-similar-functions                     merges similar functions when
-;; CHECK-NEXT:                                                 benefical
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --metrics                                     reports metrics (with an
-;; CHECK-NEXT:                                                 optional title,
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --merge-similar-functions                     merges similar functions when 
+;; CHECK-NEXT:                                                 beneficial
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --metrics                                     reports metrics (with an 
+;; CHECK-NEXT:                                                 optional title, 
 ;; CHECK-NEXT:                                                 --metrics[=TITLE])
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --minify-imports                              minifies import names (only
-;; CHECK-NEXT:                                                 those, and not export names),
-;; CHECK-NEXT:                                                 and emits a mapping to the
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --minify-imports                              minifies import names (only 
+;; CHECK-NEXT:                                                 those, and not export names), 
+;; CHECK-NEXT:                                                 and emits a mapping to the 
 ;; CHECK-NEXT:                                                 minified ones
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --minify-imports-and-exports                  minifies both import and export
-;; CHECK-NEXT:                                                 names, and emits a mapping to
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --minify-imports-and-exports                  minifies both import and export 
+;; CHECK-NEXT:                                                 names, and emits a mapping to 
 ;; CHECK-NEXT:                                                 the minified ones
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --minify-imports-and-exports-and-modules      minifies both import and export
-;; CHECK-NEXT:                                                 names, and emits a mapping to
-;; CHECK-NEXT:                                                 the minified ones, and minifies
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --minify-imports-and-exports-and-modules      minifies both import and export 
+;; CHECK-NEXT:                                                 names, and emits a mapping to 
+;; CHECK-NEXT:                                                 the minified ones, and minifies 
 ;; CHECK-NEXT:                                                 the modules as well
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --minimize-rec-groups                         Split types into minimal
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --minimize-rec-groups                         Split types into minimal 
 ;; CHECK-NEXT:                                                 recursion groups
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --monomorphize                                creates specialized versions of
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --monomorphize                                creates specialized versions of 
 ;; CHECK-NEXT:                                                 functions
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --monomorphize-always                         creates specialized versions of
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --monomorphize-always                         creates specialized versions of 
 ;; CHECK-NEXT:                                                 functions (even if unhelpful)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --multi-memory-lowering                       combines multiple memories into
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --multi-memory-lowering                       combines multiple memories into 
 ;; CHECK-NEXT:                                                 a single memory
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --multi-memory-lowering-with-bounds-checks    combines multiple memories into
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --multi-memory-lowering-with-bounds-checks    combines multiple memories into 
 ;; CHECK-NEXT:                                                 a single memory, trapping if the
 ;; CHECK-NEXT:                                                 read or write is larger than the
 ;; CHECK-NEXT:                                                 length of the memory's data
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --name-types                                  (re)name all heap types
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --nm                                          name list
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --no-full-inline                              mark functions as no-inline (for
 ;; CHECK-NEXT:                                                 full inlining only)
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --no-inline                                   mark functions as no-inline
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --no-partial-inline                           mark functions as no-inline (for
 ;; CHECK-NEXT:                                                 partial inlining only)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --once-reduction                              reduces calls to code that only
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --once-reduction                              reduces calls to code that only 
 ;; CHECK-NEXT:                                                 runs once
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --optimize-added-constants                    optimizes added constants into
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --optimize-added-constants                    optimizes added constants into 
 ;; CHECK-NEXT:                                                 load/store offsets
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --optimize-added-constants-propagate          optimizes added constants into
-;; CHECK-NEXT:                                                 load/store offsets, propagating
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --optimize-added-constants-propagate          optimizes added constants into 
+;; CHECK-NEXT:                                                 load/store offsets, propagating 
 ;; CHECK-NEXT:                                                 them across locals too
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --optimize-casts                              eliminate and reuse casts
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --optimize-for-js                             early optimize of the
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --optimize-for-js                             early optimize of the 
 ;; CHECK-NEXT:                                                 instruction combinations for js
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --optimize-instructions                       optimizes instruction
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --optimize-instructions                       optimizes instruction 
 ;; CHECK-NEXT:                                                 combinations
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --optimize-j2cl                               optimizes J2CL specific
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --optimize-j2cl                               optimizes J2CL specific 
 ;; CHECK-NEXT:                                                 constructs.
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --outlining                                   outline instructions
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --pick-load-signs                             pick load signs based on their
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --pick-load-signs                             pick load signs based on their 
 ;; CHECK-NEXT:                                                 uses
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --poppify                                     Transform Binaryen IR into Poppy
 ;; CHECK-NEXT:                                                 IR
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --post-emscripten                             miscellaneous optimizations for
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --post-emscripten                             miscellaneous optimizations for 
 ;; CHECK-NEXT:                                                 Emscripten-generated code
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --precompute                                  computes compile-time
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --precompute                                  computes compile-time 
 ;; CHECK-NEXT:                                                 evaluatable expressions
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --precompute-propagate                        computes compile-time
-;; CHECK-NEXT:                                                 evaluatable expressions and
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --precompute-propagate                        computes compile-time 
+;; CHECK-NEXT:                                                 evaluatable expressions and 
 ;; CHECK-NEXT:                                                 propagates them through locals
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --print                                       print in s-expression format
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --print-boundary                              print boundary in JSON format
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --print-call-graph                            print call graph
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --print-features                              print options for enabled
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --print-features                              print options for enabled 
 ;; CHECK-NEXT:                                                 features
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --print-full                                  print in full s-expression
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --print-full                                  print in full s-expression 
 ;; CHECK-NEXT:                                                 format
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --print-function-map                          print a map of function indexes
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --print-function-map                          print a map of function indexes 
 ;; CHECK-NEXT:                                                 to names
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --print-minified                              print in minified s-expression
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --print-minified                              print in minified s-expression 
 ;; CHECK-NEXT:                                                 format
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --propagate-debug-locs                        propagate debug location from
-;; CHECK-NEXT:                                                 parents or previous siblings to
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --propagate-debug-locs                        propagate debug location from 
+;; CHECK-NEXT:                                                 parents or previous siblings to 
 ;; CHECK-NEXT:                                                 child nodes
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --propagate-globals-globally                  propagate global values to other
 ;; CHECK-NEXT:                                                 globals (useful for tests)
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --remove-empty-function-exports               removes exports of empty
+;; CHECK-NEXT:                                                 functions
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --remove-exports                              removes exports using a wildcard
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --remove-imports                              removes imports and replaces
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --remove-imports                              removes imports and replaces 
 ;; CHECK-NEXT:                                                 them with nops
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --remove-memory                               removes memory init (legacy
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --remove-memory                               removes memory init (legacy 
 ;; CHECK-NEXT:                                                 name)
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --remove-memory-init                          removes memory initialization
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --remove-non-js-ops                           removes operations incompatible
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --remove-non-js-ops                           removes operations incompatible 
 ;; CHECK-NEXT:                                                 with js
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --remove-relaxed-simd                         replaces relaxed SIMD
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --remove-relaxed-simd                         replaces relaxed SIMD 
 ;; CHECK-NEXT:                                                 instructions with unreachable
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --remove-unused-brs                           removes breaks from locations
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --remove-unused-brs                           removes breaks from locations 
 ;; CHECK-NEXT:                                                 that are not needed
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --remove-unused-module-elements               removes unused module elements
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --remove-unused-names                         removes names from locations
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --remove-unused-names                         removes names from locations 
 ;; CHECK-NEXT:                                                 that are never branched to
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --remove-unused-nonfunction-module-elements   removes unused module elements
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --remove-unused-nonfunction-module-elements   removes unused module elements 
 ;; CHECK-NEXT:                                                 that are not functions
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --remove-unused-types                         remove unused private GC types
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --reorder-functions                           sorts functions by access
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --reorder-functions                           sorts functions by access 
 ;; CHECK-NEXT:                                                 frequency
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --reorder-functions-by-name                   sorts functions by name (useful
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --reorder-functions-by-name                   sorts functions by name (useful 
 ;; CHECK-NEXT:                                                 for debugging)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --reorder-globals                             sorts globals by access
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --reorder-globals                             sorts globals by access 
 ;; CHECK-NEXT:                                                 frequency
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --reorder-locals                              sorts locals by access frequency
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --reorder-types                               sorts private types by access
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --reorder-types                               sorts private types by access 
 ;; CHECK-NEXT:                                                 frequency
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --rereloop                                    re-optimize control flow using
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --rereloop                                    re-optimize control flow using 
 ;; CHECK-NEXT:                                                 the relooper algorithm
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --roundtrip                                   write the module to binary, then
 ;; CHECK-NEXT:                                                 read it
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --rse                                         remove redundant local.sets
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --safe-heap                                   instrument loads and stores to
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --safe-heap                                   instrument loads and stores to 
 ;; CHECK-NEXT:                                                 check for invalid behavior
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --separate-data-segments                      write data segments to a file
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --separate-data-segments                      write data segments to a file 
 ;; CHECK-NEXT:                                                 and strip them from the module
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --set-globals                                 sets specified globals to
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --set-globals                                 sets specified globals to 
 ;; CHECK-NEXT:                                                 specified values
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --signature-pruning                           remove params from function
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --signature-pruning                           remove params from function 
 ;; CHECK-NEXT:                                                 signature types where possible
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --signature-refining                          apply more specific subtypes to
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --signature-refining                          apply more specific subtypes to 
 ;; CHECK-NEXT:                                                 signature types where possible
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --signext-lowering                            lower sign-ext operations to
-;; CHECK-NEXT:                                                 wasm mvp and disable the sign
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --signext-lowering                            lower sign-ext operations to 
+;; CHECK-NEXT:                                                 wasm mvp and disable the sign 
 ;; CHECK-NEXT:                                                 extension feature
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --simplify-globals                            miscellaneous globals-related
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --simplify-globals                            miscellaneous globals-related 
 ;; CHECK-NEXT:                                                 optimizations
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --simplify-globals-optimizing                 miscellaneous globals-related
-;; CHECK-NEXT:                                                 optimizations, and optimizes
-;; CHECK-NEXT:                                                 where we replaced global.gets
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --simplify-globals-optimizing                 miscellaneous globals-related 
+;; CHECK-NEXT:                                                 optimizations, and optimizes 
+;; CHECK-NEXT:                                                 where we replaced global.gets 
 ;; CHECK-NEXT:                                                 with constants
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --simplify-locals                             miscellaneous locals-related
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --simplify-locals                             miscellaneous locals-related 
 ;; CHECK-NEXT:                                                 optimizations
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --simplify-locals-nonesting                   miscellaneous locals-related
-;; CHECK-NEXT:                                                 optimizations (no nesting at
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --simplify-locals-nonesting                   miscellaneous locals-related 
+;; CHECK-NEXT:                                                 optimizations (no nesting at 
 ;; CHECK-NEXT:                                                 all; preserves flatness)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --simplify-locals-nostructure                 miscellaneous locals-related
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --simplify-locals-nostructure                 miscellaneous locals-related 
 ;; CHECK-NEXT:                                                 optimizations (no structure)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --simplify-locals-notee                       miscellaneous locals-related
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --simplify-locals-notee                       miscellaneous locals-related 
 ;; CHECK-NEXT:                                                 optimizations (no tees)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --simplify-locals-notee-nostructure           miscellaneous locals-related
-;; CHECK-NEXT:                                                 optimizations (no tees or
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --simplify-locals-notee-nostructure           miscellaneous locals-related 
+;; CHECK-NEXT:                                                 optimizations (no tees or 
 ;; CHECK-NEXT:                                                 structure)
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --souperify                                   emit Souper IR in text form
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --souperify-single-use                        emit Souper IR in text form
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --souperify-single-use                        emit Souper IR in text form 
 ;; CHECK-NEXT:                                                 (single-use nodes only)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --spill-pointers                              spill pointers to the C stack
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --spill-pointers                              spill pointers to the C stack 
 ;; CHECK-NEXT:                                                 (useful for Boehm-style GC)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --ssa                                         ssa-ify variables so that they
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --ssa                                         ssa-ify variables so that they 
 ;; CHECK-NEXT:                                                 have a single assignment
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --ssa-nomerge                                 ssa-ify variables so that they
-;; CHECK-NEXT:                                                 have a single assignment,
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --ssa-nomerge                                 ssa-ify variables so that they 
+;; CHECK-NEXT:                                                 have a single assignment, 
 ;; CHECK-NEXT:                                                 ignoring merges
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --stack-check                                 enforce limits on llvm's
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --stack-check                                 enforce limits on llvm's 
 ;; CHECK-NEXT:                                                 __stack_pointer global
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --string-gathering                            gathers wasm strings to globals
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --string-lifting                              lift string imports to wasm
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --string-lifting                              lift string imports to wasm 
 ;; CHECK-NEXT:                                                 strings
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --string-lowering                             lowers wasm strings and
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --string-lowering                             lowers wasm strings and 
 ;; CHECK-NEXT:                                                 operations to imports
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --string-lowering-magic-imports               same as string-lowering, but
-;; CHECK-NEXT:                                                 encodes well-formed strings as
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --string-lowering-magic-imports               same as string-lowering, but 
+;; CHECK-NEXT:                                                 encodes well-formed strings as 
 ;; CHECK-NEXT:                                                 magic imports
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --string-lowering-magic-imports-assert        same as
-;; CHECK-NEXT:                                                 string-lowering-magic-imports,
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --string-lowering-magic-imports-assert        same as 
+;; CHECK-NEXT:                                                 string-lowering-magic-imports, 
 ;; CHECK-NEXT:                                                 but raise a fatal error if there
 ;; CHECK-NEXT:                                                 are invalid strings
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --strip                                       deprecated; same as strip-debug
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --strip-debug                                 strip debug info (including the
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --strip-debug                                 strip debug info (including the 
 ;; CHECK-NEXT:                                                 names section)
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --strip-dwarf                                 strip dwarf debug info
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --strip-eh                                    strip EH instructions
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --strip-producers                             strip the wasm producers section
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --strip-target-features                       strip the wasm target features
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --strip-target-features                       strip the wasm target features 
 ;; CHECK-NEXT:                                                 section
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --strip-toolchain-annotations                 strip all toolchain-specific
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --strip-toolchain-annotations                 strip all toolchain-specific 
 ;; CHECK-NEXT:                                                 code annotations
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --stub-unsupported-js                         stub out unsupported JS
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --stub-unsupported-js                         stub out unsupported JS 
 ;; CHECK-NEXT:                                                 operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --symbolmap                                   (alias for print-function-map)
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --table64-lowering                            alias for memory64-lowering
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --trace-calls                                 instrument the build with code
-;; CHECK-NEXT:                                                 to intercept specific function
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --tail-call                                   convert calls in tail position 
+;; CHECK-NEXT:                                                 to return calls
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --trace-calls                                 instrument the build with code 
+;; CHECK-NEXT:                                                 to intercept specific function 
 ;; CHECK-NEXT:                                                 calls
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --translate-to-exnref                         translate old Phase 3 EH
-;; CHECK-NEXT:                                                 instructions to new ones with
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --translate-to-exnref                         translate old Phase 3 EH 
+;; CHECK-NEXT:                                                 instructions to new ones with 
 ;; CHECK-NEXT:                                                 exnref
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --translate-to-new-eh                         deprecated; same as
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --translate-to-new-eh                         deprecated; same as 
 ;; CHECK-NEXT:                                                 translate-to-exnref
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --trap-mode-clamp                             replace trapping operations with
-;; CHECK-NEXT:                                                 clamping semantics
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --trap-mode-js                                replace trapping operations with
-;; CHECK-NEXT:                                                 js semantics
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --tuple-optimization                          optimize trivial tuples away
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --type-finalizing                             mark all leaf types as final
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --type-merging                                merge types to their supertypes
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --type-merging                                merge types to their supertypes 
 ;; CHECK-NEXT:                                                 where possible
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --type-refining                               apply more specific subtypes to
-;; CHECK-NEXT:                                                 type fields where possible
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --type-refining-gufa                          apply more specific subtypes to
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --type-refining                               apply more specific subtypes to 
 ;; CHECK-NEXT:                                                 type fields where possible
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --type-refining-gufa                          apply more specific subtypes to 
+;; CHECK-NEXT:                                                 type fields where possible 
 ;; CHECK-NEXT:                                                 (using GUFA)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --type-ssa                                    create new types to help other
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --type-ssa                                    create new types to help other 
 ;; CHECK-NEXT:                                                 optimizations
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --type-unfinalizing                           mark all types as non-final
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --type-unfinalizing                           mark all types as non-final 
 ;; CHECK-NEXT:                                                 (open)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --unsubtyping                                 removes unnecessary subtyping
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --unsubtyping                                 removes unnecessary subtyping 
 ;; CHECK-NEXT:                                                 relationships
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --untee                                       removes local.tees, replacing
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --untee                                       removes local.tees, replacing 
 ;; CHECK-NEXT:                                                 them with sets and gets
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --vacuum                                      removes obviously unneeded code
-;; CHECK-NEXT:
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT: Optimization options:
 ;; CHECK-NEXT: ---------------------
-;; CHECK-NEXT:
-;; CHECK-NEXT:    -O                                           execute default optimization
+;; CHECK-EMPTY:
+;; CHECK-NEXT:    -O                                           execute default optimization 
 ;; CHECK-NEXT:                                                 passes (equivalent to -Os)
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:    -O0                                          execute no optimization passes
-;; CHECK-NEXT:
-;; CHECK-NEXT:    -O1                                          execute -O1 optimization passes
-;; CHECK-NEXT:                                                 (quick&useful opts, useful for
+;; CHECK-EMPTY:
+;; CHECK-NEXT:    -O1                                          execute -O1 optimization passes 
+;; CHECK-NEXT:                                                 (quick&useful opts, useful for 
 ;; CHECK-NEXT:                                                 iteration builds)
-;; CHECK-NEXT:
-;; CHECK-NEXT:    -O2                                          execute -O2 optimization passes
-;; CHECK-NEXT:                                                 (most opts, generally gets most
+;; CHECK-EMPTY:
+;; CHECK-NEXT:    -O2                                          execute -O2 optimization passes 
+;; CHECK-NEXT:                                                 (most opts, generally gets most 
 ;; CHECK-NEXT:                                                 perf)
-;; CHECK-NEXT:
-;; CHECK-NEXT:    -O3                                          execute -O3 optimization passes
-;; CHECK-NEXT:                                                 (spends potentially a lot of
+;; CHECK-EMPTY:
+;; CHECK-NEXT:    -O3                                          execute -O3 optimization passes 
+;; CHECK-NEXT:                                                 (spends potentially a lot of 
 ;; CHECK-NEXT:                                                 time optimizing)
-;; CHECK-NEXT:
-;; CHECK-NEXT:    -O4                                          execute -O4 optimization passes
-;; CHECK-NEXT:                                                 (also flatten the IR, which can
+;; CHECK-EMPTY:
+;; CHECK-NEXT:    -O4                                          execute -O4 optimization passes 
+;; CHECK-NEXT:                                                 (also flatten the IR, which can 
 ;; CHECK-NEXT:                                                 take a lot more time and memory,
-;; CHECK-NEXT:                                                 but is useful on more nested /
+;; CHECK-NEXT:                                                 but is useful on more nested / 
 ;; CHECK-NEXT:                                                 complex / less-optimized input)
-;; CHECK-NEXT:
-;; CHECK-NEXT:    -Os                                          execute default optimization
+;; CHECK-EMPTY:
+;; CHECK-NEXT:    -Os                                          execute default optimization 
 ;; CHECK-NEXT:                                                 passes, focusing on code size
-;; CHECK-NEXT:
-;; CHECK-NEXT:    -Oz                                          execute default optimization
-;; CHECK-NEXT:                                                 passes, super-focusing on code
+;; CHECK-EMPTY:
+;; CHECK-NEXT:    -Oz                                          execute default optimization 
+;; CHECK-NEXT:                                                 passes, super-focusing on code 
 ;; CHECK-NEXT:                                                 size
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --optimize-level,-ol                          How much to focus on optimizing
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --optimize-level,-ol                          How much to focus on optimizing 
 ;; CHECK-NEXT:                                                 code
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --shrink-level,-s                             How much to focus on shrinking
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --shrink-level,-s                             How much to focus on shrinking 
 ;; CHECK-NEXT:                                                 code size
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --debuginfo,-g                                Emit names section in wasm
-;; CHECK-NEXT:                                                 binary (or full debuginfo in
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --debuginfo,-g                                Emit names section in wasm 
+;; CHECK-NEXT:                                                 binary (or full debuginfo in 
 ;; CHECK-NEXT:                                                 wast)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --always-inline-max-function-size,-aimfs      Max size of functions that are
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --always-inline-max-function-size,-aimfs      Max size of functions that are 
 ;; CHECK-NEXT:                                                 always inlined (default 2, which
 ;; CHECK-NEXT:                                                 is safe for use with -Os builds)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --flexible-inline-max-function-size,-fimfs    Max size of functions that are
-;; CHECK-NEXT:                                                 inlined when lightweight (no
-;; CHECK-NEXT:                                                 loops or function calls) when
-;; CHECK-NEXT:                                                 optimizing aggressively for
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --flexible-inline-max-function-size,-fimfs    Max size of functions that are 
+;; CHECK-NEXT:                                                 inlined when lightweight (no 
+;; CHECK-NEXT:                                                 loops or function calls) when 
+;; CHECK-NEXT:                                                 optimizing aggressively for 
 ;; CHECK-NEXT:                                                 speed (-O3). Default: 20
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --one-caller-inline-max-function-size,-ocimfs Max size of functions that are
-;; CHECK-NEXT:                                                 inlined when there is only one
-;; CHECK-NEXT:                                                 caller (default -1, which means
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --one-caller-inline-max-function-size,-ocimfs Max size of functions that are 
+;; CHECK-NEXT:                                                 inlined when there is only one 
+;; CHECK-NEXT:                                                 caller (default -1, which means 
 ;; CHECK-NEXT:                                                 all such functions are inlined)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --inline-max-combined-binary-size,-imcbs      Max size of combined functions
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --inline-max-combined-binary-size,-imcbs      Max size of combined functions 
 ;; CHECK-NEXT:                                                 after inlining. Default: 409600
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --inline-functions-with-loops,-ifwl           Allow inlining functions with
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --inline-functions-with-loops,-ifwl           Allow inlining functions with 
 ;; CHECK-NEXT:                                                 loops
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --partial-inlining-ifs,-pii                   Number of ifs allowed in partial
-;; CHECK-NEXT:                                                 inlining (zero means partial
-;; CHECK-NEXT:                                                 inlining is disabled) (default:
+;; CHECK-NEXT:                                                 inlining (zero means partial 
+;; CHECK-NEXT:                                                 inlining is disabled) (default: 
 ;; CHECK-NEXT:                                                 0)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --ignore-implicit-traps,-iit                  Optimize under the helpful
-;; CHECK-NEXT:                                                 assumption that no surprising
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --ignore-implicit-traps,-iit                  Optimize under the helpful 
+;; CHECK-NEXT:                                                 assumption that no surprising 
 ;; CHECK-NEXT:                                                 traps occur (from load, div/mod,
 ;; CHECK-NEXT:                                                 etc.)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --traps-never-happen,-tnh                     Optimize under the helpful
-;; CHECK-NEXT:                                                 assumption that no trap is
-;; CHECK-NEXT:                                                 reached at runtime (from load,
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --traps-never-happen,-tnh                     Optimize under the helpful 
+;; CHECK-NEXT:                                                 assumption that no trap is 
+;; CHECK-NEXT:                                                 reached at runtime (from load, 
 ;; CHECK-NEXT:                                                 div/mod, etc.)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --low-memory-unused,-lmu                      Optimize under the helpful
-;; CHECK-NEXT:                                                 assumption that the low 1K of
-;; CHECK-NEXT:                                                 memory is not used by the
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --low-memory-unused,-lmu                      Optimize under the helpful 
+;; CHECK-NEXT:                                                 assumption that the low 1K of 
+;; CHECK-NEXT:                                                 memory is not used by the 
 ;; CHECK-NEXT:                                                 application
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --fast-math,-ffm                              Optimize floats without handling
-;; CHECK-NEXT:                                                 corner cases of NaNs and
-;; CHECK-NEXT:                                                 rounding
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --zero-filled-memory,-uim                     Assume that an imported memory
+;; CHECK-NEXT:                                                 corner cases of NaNs, rounding, 
+;; CHECK-NEXT:                                                 and negative zero
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --zero-filled-memory,-uim                     Assume that an imported memory 
 ;; CHECK-NEXT:                                                 will be zero-initialized
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --skip-pass,-sp                               Skip a pass (do not run it)
-;; CHECK-NEXT:
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT: Tool options:
 ;; CHECK-NEXT: -------------
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --mvp-features,-mvp                           Disable all non-MVP features
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --all-features,-all                           Enable all features
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --detect-features                             (deprecated - this flag does
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --detect-features                             (deprecated - this flag does 
 ;; CHECK-NEXT:                                                 nothing)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --quiet,-q                                    Emit less verbose output and
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --quiet,-q                                    Emit less verbose output and 
 ;; CHECK-NEXT:                                                 hide trivial warnings.
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --experimental-poppy                          Parse wast files as Poppy IR for
 ;; CHECK-NEXT:                                                 testing purposes.
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --emit-module-names                           Emit module names, even if not
-;; CHECK-NEXT:                                                 emitting the rest of the names
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --emit-module-names                           Emit module names, even if not 
+;; CHECK-NEXT:                                                 emitting the rest of the names 
 ;; CHECK-NEXT:                                                 section.
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-sign-ext                             Enable sign extension operations
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --disable-sign-ext                            Disable sign extension
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --disable-sign-ext                            Disable sign extension 
 ;; CHECK-NEXT:                                                 operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-threads                              Enable atomic operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-threads                             Disable atomic operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-mutable-globals                      Enable mutable globals
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-mutable-globals                     Disable mutable globals
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --enable-nontrapping-float-to-int             Enable nontrapping float-to-int
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --enable-nontrapping-float-to-int             Enable nontrapping float-to-int 
 ;; CHECK-NEXT:                                                 operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-nontrapping-float-to-int            Disable nontrapping float-to-int
 ;; CHECK-NEXT:                                                 operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-simd                                 Enable SIMD operations and types
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --disable-simd                                Disable SIMD operations and
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --disable-simd                                Disable SIMD operations and 
 ;; CHECK-NEXT:                                                 types
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-bulk-memory                          Enable bulk memory operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-bulk-memory                         Disable bulk memory operations
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --enable-bulk-memory-opt                      Enable memory.copy and
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --enable-bulk-memory-opt                      Enable memory.copy and 
 ;; CHECK-NEXT:                                                 memory.fill
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --disable-bulk-memory-opt                     Disable memory.copy and
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --disable-bulk-memory-opt                     Disable memory.copy and 
 ;; CHECK-NEXT:                                                 memory.fill
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --enable-call-indirect-overlong               Enable LEB encoding of
-;; CHECK-NEXT:                                                 call-indirect (Ignored for
-;; CHECK-NEXT:                                                 compatibility as it has no
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --enable-call-indirect-overlong               Enable LEB encoding of 
+;; CHECK-NEXT:                                                 call-indirect (Ignored for 
+;; CHECK-NEXT:                                                 compatibility as it has no 
 ;; CHECK-NEXT:                                                 effect on Binaryen)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --disable-call-indirect-overlong              Disable LEB encoding of
-;; CHECK-NEXT:                                                 call-indirect (Ignored for
-;; CHECK-NEXT:                                                 compatibility as it has no
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --disable-call-indirect-overlong              Disable LEB encoding of 
+;; CHECK-NEXT:                                                 call-indirect (Ignored for 
+;; CHECK-NEXT:                                                 compatibility as it has no 
 ;; CHECK-NEXT:                                                 effect on Binaryen)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --enable-exception-handling                   Enable exception handling
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --enable-exception-handling                   Enable exception handling 
 ;; CHECK-NEXT:                                                 operations
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --disable-exception-handling                  Disable exception handling
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --disable-exception-handling                  Disable exception handling 
 ;; CHECK-NEXT:                                                 operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-tail-call                            Enable tail call operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-tail-call                           Disable tail call operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-reference-types                      Enable reference types
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-reference-types                     Disable reference types
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-multivalue                           Enable multivalue functions
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-multivalue                          Disable multivalue functions
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-gc                                   Enable garbage collection
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-gc                                  Disable garbage collection
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-memory64                             Enable memory64
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-memory64                            Disable memory64
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-relaxed-simd                         Enable relaxed SIMD
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-relaxed-simd                        Disable relaxed SIMD
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --enable-extended-const                       Enable extended const
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --enable-extended-const                       Enable extended const 
 ;; CHECK-NEXT:                                                 expressions
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --disable-extended-const                      Disable extended const
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --disable-extended-const                      Disable extended const 
 ;; CHECK-NEXT:                                                 expressions
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-strings                              Enable strings
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-strings                             Disable strings
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-multimemory                          Enable multimemory
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-multimemory                         Disable multimemory
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-stack-switching                      Enable stack switching
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-stack-switching                     Disable stack switching
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-shared-everything                    Enable shared-everything threads
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --disable-shared-everything                   Disable shared-everything
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --disable-shared-everything                   Disable shared-everything 
 ;; CHECK-NEXT:                                                 threads
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-fp16                                 Enable float 16 operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-fp16                                Disable float 16 operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-custom-descriptors                   Enable custom descriptors (RTTs)
 ;; CHECK-NEXT:                                                 and exact references
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --disable-custom-descriptors                  Disable custom descriptors
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --disable-custom-descriptors                  Disable custom descriptors 
 ;; CHECK-NEXT:                                                 (RTTs) and exact references
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-multibyte                            Enable multibyte array loads and
 ;; CHECK-NEXT:                                                 stores
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --disable-multibyte                           Disable multibyte array loads
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --disable-multibyte                           Disable multibyte array loads 
 ;; CHECK-NEXT:                                                 and stores
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --enable-acquire-release-atomics              Enable acquire/release atomic
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --enable-acquire-release-atomics              Enable acquire/release atomic 
 ;; CHECK-NEXT:                                                 memory operations
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --disable-acquire-release-atomics             Disable acquire/release atomic
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --disable-acquire-release-atomics             Disable acquire/release atomic 
 ;; CHECK-NEXT:                                                 memory operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-custom-page-sizes                    Enable custom page sizes
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-custom-page-sizes                   Disable custom page sizes
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-wide-arithmetic                      Enable wide arithmetic
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-wide-arithmetic                     Disable wide arithmetic
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-compact-imports                      Enable compact import section
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-compact-imports                     Disable compact import section
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --enable-relaxed-atomics                      Enable relaxed atomic memory
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --enable-relaxed-atomics                      Enable relaxed atomic memory 
 ;; CHECK-NEXT:                                                 operations
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --disable-relaxed-atomics                     Disable relaxed atomic memory
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --disable-relaxed-atomics                     Disable relaxed atomic memory 
 ;; CHECK-NEXT:                                                 operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-typed-function-references            Deprecated compatibility flag
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-typed-function-references           Deprecated compatibility flag
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --no-validation,-n                            Disables validation, assumes
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --no-validation,-n                            Disables validation, assumes 
 ;; CHECK-NEXT:                                                 inputs are correct
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --pass-arg,-pa                                An argument passed along to
-;; CHECK-NEXT:                                                 optimization passes being run.
-;; CHECK-NEXT:                                                 Must be in the form KEY@VALUE.
-;; CHECK-NEXT:                                                 If KEY is the name of a pass
-;; CHECK-NEXT:                                                 then it applies to the closest
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --pass-arg,-pa                                An argument passed along to 
+;; CHECK-NEXT:                                                 optimization passes being run. 
+;; CHECK-NEXT:                                                 Must be in the form KEY@VALUE.  
+;; CHECK-NEXT:                                                 If KEY is the name of a pass 
+;; CHECK-NEXT:                                                 then it applies to the closest 
 ;; CHECK-NEXT:                                                 instance of that pass before us.
 ;; CHECK-NEXT:                                                 If KEY is not the name of a pass
-;; CHECK-NEXT:                                                 then it is a global option that
-;; CHECK-NEXT:                                                 applies to all pass instances
+;; CHECK-NEXT:                                                 then it is a global option that 
+;; CHECK-NEXT:                                                 applies to all pass instances 
 ;; CHECK-NEXT:                                                 that read it.
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --closed-world,-cw                            Assume code outside of the
-;; CHECK-NEXT:                                                 module does not inspect or
-;; CHECK-NEXT:                                                 interact with GC and function
-;; CHECK-NEXT:                                                 references, even if they are
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --closed-world,-cw                            Assume code outside of the 
+;; CHECK-NEXT:                                                 module does not inspect or 
+;; CHECK-NEXT:                                                 interact with GC and function 
+;; CHECK-NEXT:                                                 references, even if they are 
 ;; CHECK-NEXT:                                                 passed out. The outside may hold
-;; CHECK-NEXT:                                                 on to them and pass them back
-;; CHECK-NEXT:                                                 in, but not inspect their
+;; CHECK-NEXT:                                                 on to them and pass them back 
+;; CHECK-NEXT:                                                 in, but not inspect their 
 ;; CHECK-NEXT:                                                 contents or call them.
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --preserve-type-order                         Preserve the order of types from
-;; CHECK-NEXT:                                                 the input (useful for debugging
+;; CHECK-NEXT:                                                 the input (useful for debugging 
 ;; CHECK-NEXT:                                                 and testing)
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --generate-stack-ir                           generate StackIR during writing
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --optimize-stack-ir                           optimize StackIR during writing
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --print-stack-ir                              print StackIR during writing
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --no-stack-ir                                 do not use StackIR (even when it
 ;; CHECK-NEXT:                                                 is the default)
-;; CHECK-NEXT:
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT: General options:
 ;; CHECK-NEXT: ----------------
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --version                                     Output version information and
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --version                                     Output version information and 
 ;; CHECK-NEXT:                                                 exit
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --help,-h                                     Show this help message and exit
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --debug,-d                                    Print debug information to
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --debug,-d                                    Print debug information to 
 ;; CHECK-NEXT:                                                 stderr
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
diff --git a/test/lit/help/wasm-opt.test b/test/lit/help/wasm-opt.test
index 16a7a643ed4..568b3fef689 100644
--- a/test/lit/help/wasm-opt.test
+++ b/test/lit/help/wasm-opt.test
@@ -1,935 +1,935 @@
 ;; RUN: wasm-opt --help | filecheck %s
 ;; CHECK: ================================================================================
 ;; CHECK-NEXT: wasm-opt INFILE
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT: Read, write, and optimize files.
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT: Example usage:
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   wasm-opt input.wasm -O3 -o output.wasm
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT: This reads an input wasm file, optimizes with -O3, and writes out the result.
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT: For more on how to optimize effectively, see
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   https://github.com/WebAssembly/binaryen/wiki/Optimizer-Cookbook
 ;; CHECK-NEXT:   https://github.com/WebAssembly/binaryen/wiki/GC-Optimization-Guidebook
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT: ================================================================================
-;; CHECK-NEXT:
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT: wasm-opt options:
 ;; CHECK-NEXT: -----------------
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --output,-o                                   Output file
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --emit-text,-S                                Emit text instead of binary for
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --emit-text,-S                                Emit text instead of binary for 
 ;; CHECK-NEXT:                                                 the output file
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --converge,-c                                 Run passes to convergence,
-;; CHECK-NEXT:                                                 continuing while binary size
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --converge,-c                                 Run passes to convergence, 
+;; CHECK-NEXT:                                                 continuing while binary size 
 ;; CHECK-NEXT:                                                 decreases
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --fuzz-exec-before,-feh                       Execute functions before
-;; CHECK-NEXT:                                                 optimization, helping fuzzing
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --fuzz-exec-before,-feh                       Execute functions before 
+;; CHECK-NEXT:                                                 optimization, helping fuzzing 
 ;; CHECK-NEXT:                                                 find bugs
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --fuzz-exec,-fe                               Execute functions before and
-;; CHECK-NEXT:                                                 after optimization, helping
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --fuzz-exec,-fe                               Execute functions before and 
+;; CHECK-NEXT:                                                 after optimization, helping 
 ;; CHECK-NEXT:                                                 fuzzing find bugs
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --fuzz-exec-second                            A second module to link with the
-;; CHECK-NEXT:                                                 first, for fuzz-exec-before
-;; CHECK-NEXT:                                                 (only before, as optimizations
+;; CHECK-NEXT:                                                 first, for fuzz-exec-before 
+;; CHECK-NEXT:                                                 (only before, as optimizations 
 ;; CHECK-NEXT:                                                 are not applied to it)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --extra-fuzz-command,-efc                     An extra command to run on the
-;; CHECK-NEXT:                                                 output before and after
-;; CHECK-NEXT:                                                 optimizing. The output is
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --extra-fuzz-command,-efc                     An extra command to run on the 
+;; CHECK-NEXT:                                                 output before and after 
+;; CHECK-NEXT:                                                 optimizing. The output is 
 ;; CHECK-NEXT:                                                 compared between the two, and an
-;; CHECK-NEXT:                                                 error occurs if they are not
+;; CHECK-NEXT:                                                 error occurs if they are not 
 ;; CHECK-NEXT:                                                 equal
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --translate-to-fuzz,-ttf                      Translate the input into a valid
-;; CHECK-NEXT:                                                 wasm module *somehow*, useful
+;; CHECK-NEXT:                                                 wasm module *somehow*, useful 
 ;; CHECK-NEXT:                                                 for fuzzing
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --initial-fuzz,-if                            Initial wasm content in
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --initial-fuzz,-if                            Initial wasm content in 
 ;; CHECK-NEXT:                                                 translate-to-fuzz (-ttf) mode
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --fuzz-passes,-fp                             When doing translate-to-fuzz,
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --fuzz-passes,-fp                             When doing translate-to-fuzz, 
 ;; CHECK-NEXT:                                                 pick a set of random passes from
-;; CHECK-NEXT:                                                 the input to further shape the
+;; CHECK-NEXT:                                                 the input to further shape the 
 ;; CHECK-NEXT:                                                 wasm
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --no-fuzz-memory                              don't emit memory ops when
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --no-fuzz-memory                              don't emit memory ops when 
 ;; CHECK-NEXT:                                                 fuzzing
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --no-fuzz-oob                                 don't emit out-of-bounds
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --no-fuzz-oob                                 don't emit out-of-bounds 
 ;; CHECK-NEXT:                                                 loads/stores/indirect calls when
 ;; CHECK-NEXT:                                                 fuzzing
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --fuzz-preserve-imports-exports               don't add imports and exports in
 ;; CHECK-NEXT:                                                 -ttf mode, and keep the start
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --fuzz-against-js                             modify the wasm in valid ways
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --fuzz-against-js                             modify the wasm in valid ways 
 ;; CHECK-NEXT:                                                 that assume it is used only from
 ;; CHECK-NEXT:                                                 JS
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --fuzz-import                                 a module to use as an import in
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --fuzz-import                                 a module to use as an import in 
 ;; CHECK-NEXT:                                                 -ttf mode
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --emit-spec-wrapper,-esw                      Emit a wasm spec interpreter
-;; CHECK-NEXT:                                                 wrapper file that can run the
-;; CHECK-NEXT:                                                 wasm with some test values,
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --emit-spec-wrapper,-esw                      Emit a wasm spec interpreter 
+;; CHECK-NEXT:                                                 wrapper file that can run the 
+;; CHECK-NEXT:                                                 wasm with some test values, 
 ;; CHECK-NEXT:                                                 useful for fuzzing
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --emit-wasm2c-wrapper,-esw                    Emit a C wrapper file that can
-;; CHECK-NEXT:                                                 run the wasm after it is
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --emit-wasm2c-wrapper,-esw                    Emit a C wrapper file that can 
+;; CHECK-NEXT:                                                 run the wasm after it is 
 ;; CHECK-NEXT:                                                 compiled with wasm2c, useful for
 ;; CHECK-NEXT:                                                 fuzzing
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --input-source-map,-ism                       Consume source map from the
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --input-source-map,-ism                       Consume source map from the 
 ;; CHECK-NEXT:                                                 specified file
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --output-source-map,-osm                      Emit source map to the specified
 ;; CHECK-NEXT:                                                 file
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --output-source-map-url,-osu                  Emit specified string as source
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --output-source-map-url,-osu                  Emit specified string as source 
 ;; CHECK-NEXT:                                                 map URL
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --experimental-new-eh                         Deprecated; same as
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --experimental-new-eh                         Deprecated; same as 
 ;; CHECK-NEXT:                                                 --emit-exnref
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --emit-exnref                                 After running all requested
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --emit-exnref                                 After running all requested 
 ;; CHECK-NEXT:                                                 transformations / optimizations,
 ;; CHECK-NEXT:                                                 translate the instruction to use
-;; CHECK-NEXT:                                                 the new EH instructions at the
-;; CHECK-NEXT:                                                 end. Depending on the
-;; CHECK-NEXT:                                                 optimization level specified,
-;; CHECK-NEXT:                                                 this may do some more
+;; CHECK-NEXT:                                                 the new EH instructions at the 
+;; CHECK-NEXT:                                                 end. Depending on the 
+;; CHECK-NEXT:                                                 optimization level specified, 
+;; CHECK-NEXT:                                                 this may do some more 
 ;; CHECK-NEXT:                                                 post-translation optimizations.
-;; CHECK-NEXT:
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT: Optimization passes:
 ;; CHECK-NEXT: --------------------
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --abstract-type-refining                      refine and merge abstract
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --abstract-type-refining                      refine and merge abstract 
 ;; CHECK-NEXT:                                                 (never-created) types
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --alignment-lowering                          lower unaligned loads and stores
 ;; CHECK-NEXT:                                                 to smaller aligned ones
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --asyncify                                    async/await style transform,
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --asyncify                                    async/await style transform, 
 ;; CHECK-NEXT:                                                 allowing pausing and resuming
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --avoid-reinterprets                          Tries to avoid reinterpret
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --avoid-reinterprets                          Tries to avoid reinterpret 
 ;; CHECK-NEXT:                                                 operations via more loads
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --cfp                                         propagate constant struct field
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --cfp                                         propagate constant struct field 
 ;; CHECK-NEXT:                                                 values
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --cfp-reftest                                 propagate constant struct field
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --cfp-reftest                                 propagate constant struct field 
 ;; CHECK-NEXT:                                                 values, using ref.test
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --coalesce-locals                             reduce # of locals by coalescing
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --coalesce-locals-learning                    reduce # of locals by coalescing
 ;; CHECK-NEXT:                                                 and learning
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --code-folding                                fold code, merging duplicates
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --code-pushing                                push code forward, potentially
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --code-pushing                                push code forward, potentially 
 ;; CHECK-NEXT:                                                 making it not always execute
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --const-hoisting                              hoist repeated constants to a
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --const-hoisting                              hoist repeated constants to a 
 ;; CHECK-NEXT:                                                 local
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --constraint-analysis                         finds and uses mathematical
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --constraint-analysis                         finds and uses mathematical 
 ;; CHECK-NEXT:                                                 constraints on locals
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --dae                                         removes arguments to calls in an
 ;; CHECK-NEXT:                                                 lto-like manner
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --dae-optimizing                              removes arguments to calls in an
-;; CHECK-NEXT:                                                 lto-like manner, and optimizes
+;; CHECK-NEXT:                                                 lto-like manner, and optimizes 
 ;; CHECK-NEXT:                                                 where we removed
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --dae2                                        Experimental reimplementation of
 ;; CHECK-NEXT:                                                 DAE
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --dce                                         removes unreachable code
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --dealign                                     forces all loads and stores to
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --dealign                                     forces all loads and stores to 
 ;; CHECK-NEXT:                                                 have alignment 1
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --denan                                       instrument the wasm to convert
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --denan                                       instrument the wasm to convert 
 ;; CHECK-NEXT:                                                 NaNs into 0 at runtime
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --dfo                                         optimizes using the DataFlow SSA
 ;; CHECK-NEXT:                                                 IR
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --directize                                   turns indirect calls into direct
 ;; CHECK-NEXT:                                                 ones
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --discard-global-effects                      discards global effect info
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --duplicate-function-elimination              removes duplicate functions
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --duplicate-import-elimination                removes duplicate imports
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --dwarfdump                                   dump DWARF debug info sections
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --dwarfdump                                   dump DWARF debug info sections 
 ;; CHECK-NEXT:                                                 from the read binary
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --emit-target-features                        emit the target features section
 ;; CHECK-NEXT:                                                 in the output
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --enclose-world                               modify the wasm (destructively)
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --enclose-world                               modify the wasm (destructively) 
 ;; CHECK-NEXT:                                                 for closed-world
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --extract-function                            leaves just one function (useful
 ;; CHECK-NEXT:                                                 for debugging)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --extract-function-index                      leaves just one function
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --extract-function-index                      leaves just one function 
 ;; CHECK-NEXT:                                                 selected by index
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --flatten                                     flattens out code, removing
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --flatten                                     flattens out code, removing 
 ;; CHECK-NEXT:                                                 nesting
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --fpcast-emu                                  emulates function pointer casts,
-;; CHECK-NEXT:                                                 allowing incorrect indirect
+;; CHECK-NEXT:                                                 allowing incorrect indirect 
 ;; CHECK-NEXT:                                                 calls to (sometimes) work
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --func-metrics                                reports function metrics
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --generate-dyncalls                           generate dynCall functions used
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --generate-dyncalls                           generate dynCall functions used 
 ;; CHECK-NEXT:                                                 by emscripten ABI
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --generate-global-effects                     generate global effect info
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --generate-global-effects                     generate global effect info 
 ;; CHECK-NEXT:                                                 (helps later passes)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --generate-i64-dyncalls                       generate dynCall functions used
-;; CHECK-NEXT:                                                 by emscripten ABI, but only for
-;; CHECK-NEXT:                                                 functions with i64 in their
-;; CHECK-NEXT:                                                 signature (which cannot be
-;; CHECK-NEXT:                                                 invoked via the wasm table
-;; CHECK-NEXT:                                                 without JavaScript BigInt
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --generate-i64-dyncalls                       generate dynCall functions used 
+;; CHECK-NEXT:                                                 by emscripten ABI, but only for 
+;; CHECK-NEXT:                                                 functions with i64 in their 
+;; CHECK-NEXT:                                                 signature (which cannot be 
+;; CHECK-NEXT:                                                 invoked via the wasm table 
+;; CHECK-NEXT:                                                 without JavaScript BigInt 
 ;; CHECK-NEXT:                                                 support).
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --global-refining                             refine the types of globals
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --gsi                                         globally optimize struct values
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --gsi-desc-cast                               globally optimize struct values,
 ;; CHECK-NEXT:                                                 also emitting ref.cast_desc_eq
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --gto                                         globally optimize GC types
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --gufa                                        Grand Unified Flow Analysis:
-;; CHECK-NEXT:                                                 optimize the entire program
-;; CHECK-NEXT:                                                 using information about what
-;; CHECK-NEXT:                                                 content can actually appear in
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --gufa                                        Grand Unified Flow Analysis: 
+;; CHECK-NEXT:                                                 optimize the entire program 
+;; CHECK-NEXT:                                                 using information about what 
+;; CHECK-NEXT:                                                 content can actually appear in 
 ;; CHECK-NEXT:                                                 each location
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --gufa-cast-all                               GUFA plus add casts for all
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --gufa-cast-all                               GUFA plus add casts for all 
 ;; CHECK-NEXT:                                                 inferences
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --gufa-optimizing                             GUFA plus local optimizations in
 ;; CHECK-NEXT:                                                 functions we modified
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --heap-store-optimization                     optimize heap (GC) stores
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --heap2local                                  replace GC allocations with
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --heap2local                                  replace GC allocations with 
 ;; CHECK-NEXT:                                                 locals
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --i64-to-i32-lowering                         lower all uses of i64s to use
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --i64-to-i32-lowering                         lower all uses of i64s to use 
 ;; CHECK-NEXT:                                                 i32s instead
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --inline-main                                 inline __original_main into main
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --inlining                                    inline functions (you probably
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --inlining                                    inline functions (you probably 
 ;; CHECK-NEXT:                                                 want inlining-optimizing)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --inlining-optimizing                         inline functions and optimizes
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --inlining-optimizing                         inline functions and optimizes 
 ;; CHECK-NEXT:                                                 where we inlined
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --instrument-branch-hints                     instrument branch hints so we
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --instrument-branch-hints                     instrument branch hints so we 
 ;; CHECK-NEXT:                                                 can see which guessed right
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --instrument-locals                           instrument the build with code
-;; CHECK-NEXT:                                                 to intercept all loads and
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --instrument-locals                           instrument the build with code 
+;; CHECK-NEXT:                                                 to intercept all loads and 
 ;; CHECK-NEXT:                                                 stores
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --instrument-memory                           instrument the build with code
-;; CHECK-NEXT:                                                 to intercept all loads and
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --instrument-memory                           instrument the build with code 
+;; CHECK-NEXT:                                                 to intercept all loads and 
 ;; CHECK-NEXT:                                                 stores
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --intrinsic-lowering                          lower away binaryen intrinsics
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --legalize-and-prune-js-interface             legalizes the import/export
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --legalize-and-prune-js-interface             legalizes the import/export 
 ;; CHECK-NEXT:                                                 boundary and prunes when needed
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --legalize-js-interface                       legalizes i64 types on the
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --legalize-js-interface                       legalizes i64 types on the 
 ;; CHECK-NEXT:                                                 import/export boundary
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --licm                                        loop invariant code motion
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --limit-segments                              attempt to merge segments to fit
 ;; CHECK-NEXT:                                                 within web limits
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --llvm-memory-copy-fill-lowering              Lower memory.copy and
-;; CHECK-NEXT:                                                 memory.fill to wasm mvp and
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --llvm-memory-copy-fill-lowering              Lower memory.copy and 
+;; CHECK-NEXT:                                                 memory.fill to wasm mvp and 
 ;; CHECK-NEXT:                                                 disable the bulk-memory feature.
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --llvm-nontrapping-fptoint-lowering           lower nontrapping float-to-int
-;; CHECK-NEXT:                                                 operations to wasm mvp and
-;; CHECK-NEXT:                                                 disable the nontrapping fptoint
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --llvm-nontrapping-fptoint-lowering           lower nontrapping float-to-int 
+;; CHECK-NEXT:                                                 operations to wasm mvp and 
+;; CHECK-NEXT:                                                 disable the nontrapping fptoint 
 ;; CHECK-NEXT:                                                 feature
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --local-cse                                   common subexpression elimination
 ;; CHECK-NEXT:                                                 inside basic blocks
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --local-subtyping                             apply more specific subtypes to
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --local-subtyping                             apply more specific subtypes to 
 ;; CHECK-NEXT:                                                 locals where possible
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --log-execution                               instrument the build with
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --log-execution                               instrument the build with 
 ;; CHECK-NEXT:                                                 logging of where execution goes
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --make-shared-objects                         Make structs and arrays shared
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --make-shared-objects                         Make structs and arrays shared 
 ;; CHECK-NEXT:                                                 and functions unshared
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --mark-js-called                              mark js called functions (using
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --mark-js-called                              mark js called functions (using 
 ;; CHECK-NEXT:                                                 configureAll) as doing so
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --memory-packing                              packs memory into separate
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --memory-packing                              packs memory into separate 
 ;; CHECK-NEXT:                                                 segments, skipping zeros
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --memory64-lowering                           lower loads and stores to a
-;; CHECK-NEXT:                                                 64-bit memory to instead use a
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --memory64-lowering                           lower loads and stores to a 
+;; CHECK-NEXT:                                                 64-bit memory to instead use a 
 ;; CHECK-NEXT:                                                 32-bit one
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --merge-blocks                                merges blocks to their parents
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --merge-j2cl-itables                          Merges itable structures into
-;; CHECK-NEXT:                                                 vtables to make types more
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --merge-j2cl-itables                          Merges itable structures into 
+;; CHECK-NEXT:                                                 vtables to make types more 
 ;; CHECK-NEXT:                                                 compact
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --merge-locals                                merges locals when beneficial
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --merge-similar-functions                     merges similar functions when
-;; CHECK-NEXT:                                                 benefical
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --metrics                                     reports metrics (with an
-;; CHECK-NEXT:                                                 optional title,
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --merge-similar-functions                     merges similar functions when 
+;; CHECK-NEXT:                                                 beneficial
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --metrics                                     reports metrics (with an 
+;; CHECK-NEXT:                                                 optional title, 
 ;; CHECK-NEXT:                                                 --metrics[=TITLE])
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --minify-imports                              minifies import names (only
-;; CHECK-NEXT:                                                 those, and not export names),
-;; CHECK-NEXT:                                                 and emits a mapping to the
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --minify-imports                              minifies import names (only 
+;; CHECK-NEXT:                                                 those, and not export names), 
+;; CHECK-NEXT:                                                 and emits a mapping to the 
 ;; CHECK-NEXT:                                                 minified ones
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --minify-imports-and-exports                  minifies both import and export
-;; CHECK-NEXT:                                                 names, and emits a mapping to
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --minify-imports-and-exports                  minifies both import and export 
+;; CHECK-NEXT:                                                 names, and emits a mapping to 
 ;; CHECK-NEXT:                                                 the minified ones
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --minify-imports-and-exports-and-modules      minifies both import and export
-;; CHECK-NEXT:                                                 names, and emits a mapping to
-;; CHECK-NEXT:                                                 the minified ones, and minifies
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --minify-imports-and-exports-and-modules      minifies both import and export 
+;; CHECK-NEXT:                                                 names, and emits a mapping to 
+;; CHECK-NEXT:                                                 the minified ones, and minifies 
 ;; CHECK-NEXT:                                                 the modules as well
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --minimize-rec-groups                         Split types into minimal
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --minimize-rec-groups                         Split types into minimal 
 ;; CHECK-NEXT:                                                 recursion groups
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --monomorphize                                creates specialized versions of
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --monomorphize                                creates specialized versions of 
 ;; CHECK-NEXT:                                                 functions
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --monomorphize-always                         creates specialized versions of
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --monomorphize-always                         creates specialized versions of 
 ;; CHECK-NEXT:                                                 functions (even if unhelpful)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --multi-memory-lowering                       combines multiple memories into
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --multi-memory-lowering                       combines multiple memories into 
 ;; CHECK-NEXT:                                                 a single memory
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --multi-memory-lowering-with-bounds-checks    combines multiple memories into
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --multi-memory-lowering-with-bounds-checks    combines multiple memories into 
 ;; CHECK-NEXT:                                                 a single memory, trapping if the
 ;; CHECK-NEXT:                                                 read or write is larger than the
 ;; CHECK-NEXT:                                                 length of the memory's data
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --name-types                                  (re)name all heap types
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --nm                                          name list
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --no-full-inline                              mark functions as no-inline (for
 ;; CHECK-NEXT:                                                 full inlining only)
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --no-inline                                   mark functions as no-inline
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --no-partial-inline                           mark functions as no-inline (for
 ;; CHECK-NEXT:                                                 partial inlining only)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --once-reduction                              reduces calls to code that only
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --once-reduction                              reduces calls to code that only 
 ;; CHECK-NEXT:                                                 runs once
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --optimize-added-constants                    optimizes added constants into
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --optimize-added-constants                    optimizes added constants into 
 ;; CHECK-NEXT:                                                 load/store offsets
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --optimize-added-constants-propagate          optimizes added constants into
-;; CHECK-NEXT:                                                 load/store offsets, propagating
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --optimize-added-constants-propagate          optimizes added constants into 
+;; CHECK-NEXT:                                                 load/store offsets, propagating 
 ;; CHECK-NEXT:                                                 them across locals too
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --optimize-casts                              eliminate and reuse casts
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --optimize-for-js                             early optimize of the
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --optimize-for-js                             early optimize of the 
 ;; CHECK-NEXT:                                                 instruction combinations for js
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --optimize-instructions                       optimizes instruction
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --optimize-instructions                       optimizes instruction 
 ;; CHECK-NEXT:                                                 combinations
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --optimize-j2cl                               optimizes J2CL specific
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --optimize-j2cl                               optimizes J2CL specific 
 ;; CHECK-NEXT:                                                 constructs.
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --outlining                                   outline instructions
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --pick-load-signs                             pick load signs based on their
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --pick-load-signs                             pick load signs based on their 
 ;; CHECK-NEXT:                                                 uses
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --poppify                                     Transform Binaryen IR into Poppy
 ;; CHECK-NEXT:                                                 IR
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --post-emscripten                             miscellaneous optimizations for
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --post-emscripten                             miscellaneous optimizations for 
 ;; CHECK-NEXT:                                                 Emscripten-generated code
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --precompute                                  computes compile-time
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --precompute                                  computes compile-time 
 ;; CHECK-NEXT:                                                 evaluatable expressions
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --precompute-propagate                        computes compile-time
-;; CHECK-NEXT:                                                 evaluatable expressions and
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --precompute-propagate                        computes compile-time 
+;; CHECK-NEXT:                                                 evaluatable expressions and 
 ;; CHECK-NEXT:                                                 propagates them through locals
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --print                                       print in s-expression format
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --print-boundary                              print boundary in JSON format
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --print-call-graph                            print call graph
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --print-features                              print options for enabled
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --print-features                              print options for enabled 
 ;; CHECK-NEXT:                                                 features
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --print-full                                  print in full s-expression
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --print-full                                  print in full s-expression 
 ;; CHECK-NEXT:                                                 format
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --print-function-map                          print a map of function indexes
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --print-function-map                          print a map of function indexes 
 ;; CHECK-NEXT:                                                 to names
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --print-minified                              print in minified s-expression
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --print-minified                              print in minified s-expression 
 ;; CHECK-NEXT:                                                 format
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --propagate-debug-locs                        propagate debug location from
-;; CHECK-NEXT:                                                 parents or previous siblings to
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --propagate-debug-locs                        propagate debug location from 
+;; CHECK-NEXT:                                                 parents or previous siblings to 
 ;; CHECK-NEXT:                                                 child nodes
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --propagate-globals-globally                  propagate global values to other
 ;; CHECK-NEXT:                                                 globals (useful for tests)
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --remove-empty-function-exports               removes exports of empty
+;; CHECK-NEXT:                                                 functions
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --remove-exports                              removes exports using a wildcard
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --remove-imports                              removes imports and replaces
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --remove-imports                              removes imports and replaces 
 ;; CHECK-NEXT:                                                 them with nops
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --remove-memory                               removes memory init (legacy
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --remove-memory                               removes memory init (legacy 
 ;; CHECK-NEXT:                                                 name)
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --remove-memory-init                          removes memory initialization
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --remove-non-js-ops                           removes operations incompatible
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --remove-non-js-ops                           removes operations incompatible 
 ;; CHECK-NEXT:                                                 with js
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --remove-relaxed-simd                         replaces relaxed SIMD
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --remove-relaxed-simd                         replaces relaxed SIMD 
 ;; CHECK-NEXT:                                                 instructions with unreachable
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --remove-unused-brs                           removes breaks from locations
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --remove-unused-brs                           removes breaks from locations 
 ;; CHECK-NEXT:                                                 that are not needed
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --remove-unused-module-elements               removes unused module elements
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --remove-unused-names                         removes names from locations
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --remove-unused-names                         removes names from locations 
 ;; CHECK-NEXT:                                                 that are never branched to
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --remove-unused-nonfunction-module-elements   removes unused module elements
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --remove-unused-nonfunction-module-elements   removes unused module elements 
 ;; CHECK-NEXT:                                                 that are not functions
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --remove-unused-types                         remove unused private GC types
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --reorder-functions                           sorts functions by access
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --reorder-functions                           sorts functions by access 
 ;; CHECK-NEXT:                                                 frequency
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --reorder-functions-by-name                   sorts functions by name (useful
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --reorder-functions-by-name                   sorts functions by name (useful 
 ;; CHECK-NEXT:                                                 for debugging)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --reorder-globals                             sorts globals by access
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --reorder-globals                             sorts globals by access 
 ;; CHECK-NEXT:                                                 frequency
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --reorder-locals                              sorts locals by access frequency
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --reorder-types                               sorts private types by access
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --reorder-types                               sorts private types by access 
 ;; CHECK-NEXT:                                                 frequency
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --rereloop                                    re-optimize control flow using
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --rereloop                                    re-optimize control flow using 
 ;; CHECK-NEXT:                                                 the relooper algorithm
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --roundtrip                                   write the module to binary, then
 ;; CHECK-NEXT:                                                 read it
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --rse                                         remove redundant local.sets
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --safe-heap                                   instrument loads and stores to
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --safe-heap                                   instrument loads and stores to 
 ;; CHECK-NEXT:                                                 check for invalid behavior
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --separate-data-segments                      write data segments to a file
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --separate-data-segments                      write data segments to a file 
 ;; CHECK-NEXT:                                                 and strip them from the module
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --set-globals                                 sets specified globals to
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --set-globals                                 sets specified globals to 
 ;; CHECK-NEXT:                                                 specified values
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --signature-pruning                           remove params from function
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --signature-pruning                           remove params from function 
 ;; CHECK-NEXT:                                                 signature types where possible
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --signature-refining                          apply more specific subtypes to
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --signature-refining                          apply more specific subtypes to 
 ;; CHECK-NEXT:                                                 signature types where possible
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --signext-lowering                            lower sign-ext operations to
-;; CHECK-NEXT:                                                 wasm mvp and disable the sign
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --signext-lowering                            lower sign-ext operations to 
+;; CHECK-NEXT:                                                 wasm mvp and disable the sign 
 ;; CHECK-NEXT:                                                 extension feature
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --simplify-globals                            miscellaneous globals-related
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --simplify-globals                            miscellaneous globals-related 
 ;; CHECK-NEXT:                                                 optimizations
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --simplify-globals-optimizing                 miscellaneous globals-related
-;; CHECK-NEXT:                                                 optimizations, and optimizes
-;; CHECK-NEXT:                                                 where we replaced global.gets
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --simplify-globals-optimizing                 miscellaneous globals-related 
+;; CHECK-NEXT:                                                 optimizations, and optimizes 
+;; CHECK-NEXT:                                                 where we replaced global.gets 
 ;; CHECK-NEXT:                                                 with constants
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --simplify-locals                             miscellaneous locals-related
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --simplify-locals                             miscellaneous locals-related 
 ;; CHECK-NEXT:                                                 optimizations
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --simplify-locals-nonesting                   miscellaneous locals-related
-;; CHECK-NEXT:                                                 optimizations (no nesting at
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --simplify-locals-nonesting                   miscellaneous locals-related 
+;; CHECK-NEXT:                                                 optimizations (no nesting at 
 ;; CHECK-NEXT:                                                 all; preserves flatness)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --simplify-locals-nostructure                 miscellaneous locals-related
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --simplify-locals-nostructure                 miscellaneous locals-related 
 ;; CHECK-NEXT:                                                 optimizations (no structure)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --simplify-locals-notee                       miscellaneous locals-related
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --simplify-locals-notee                       miscellaneous locals-related 
 ;; CHECK-NEXT:                                                 optimizations (no tees)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --simplify-locals-notee-nostructure           miscellaneous locals-related
-;; CHECK-NEXT:                                                 optimizations (no tees or
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --simplify-locals-notee-nostructure           miscellaneous locals-related 
+;; CHECK-NEXT:                                                 optimizations (no tees or 
 ;; CHECK-NEXT:                                                 structure)
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --souperify                                   emit Souper IR in text form
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --souperify-single-use                        emit Souper IR in text form
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --souperify-single-use                        emit Souper IR in text form 
 ;; CHECK-NEXT:                                                 (single-use nodes only)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --spill-pointers                              spill pointers to the C stack
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --spill-pointers                              spill pointers to the C stack 
 ;; CHECK-NEXT:                                                 (useful for Boehm-style GC)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --ssa                                         ssa-ify variables so that they
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --ssa                                         ssa-ify variables so that they 
 ;; CHECK-NEXT:                                                 have a single assignment
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --ssa-nomerge                                 ssa-ify variables so that they
-;; CHECK-NEXT:                                                 have a single assignment,
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --ssa-nomerge                                 ssa-ify variables so that they 
+;; CHECK-NEXT:                                                 have a single assignment, 
 ;; CHECK-NEXT:                                                 ignoring merges
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --stack-check                                 enforce limits on llvm's
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --stack-check                                 enforce limits on llvm's 
 ;; CHECK-NEXT:                                                 __stack_pointer global
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --string-gathering                            gathers wasm strings to globals
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --string-lifting                              lift string imports to wasm
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --string-lifting                              lift string imports to wasm 
 ;; CHECK-NEXT:                                                 strings
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --string-lowering                             lowers wasm strings and
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --string-lowering                             lowers wasm strings and 
 ;; CHECK-NEXT:                                                 operations to imports
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --string-lowering-magic-imports               same as string-lowering, but
-;; CHECK-NEXT:                                                 encodes well-formed strings as
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --string-lowering-magic-imports               same as string-lowering, but 
+;; CHECK-NEXT:                                                 encodes well-formed strings as 
 ;; CHECK-NEXT:                                                 magic imports
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --string-lowering-magic-imports-assert        same as
-;; CHECK-NEXT:                                                 string-lowering-magic-imports,
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --string-lowering-magic-imports-assert        same as 
+;; CHECK-NEXT:                                                 string-lowering-magic-imports, 
 ;; CHECK-NEXT:                                                 but raise a fatal error if there
 ;; CHECK-NEXT:                                                 are invalid strings
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --strip                                       deprecated; same as strip-debug
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --strip-debug                                 strip debug info (including the
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --strip-debug                                 strip debug info (including the 
 ;; CHECK-NEXT:                                                 names section)
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --strip-dwarf                                 strip dwarf debug info
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --strip-eh                                    strip EH instructions
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --strip-producers                             strip the wasm producers section
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --strip-target-features                       strip the wasm target features
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --strip-target-features                       strip the wasm target features 
 ;; CHECK-NEXT:                                                 section
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --strip-toolchain-annotations                 strip all toolchain-specific
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --strip-toolchain-annotations                 strip all toolchain-specific 
 ;; CHECK-NEXT:                                                 code annotations
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --stub-unsupported-js                         stub out unsupported JS
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --stub-unsupported-js                         stub out unsupported JS 
 ;; CHECK-NEXT:                                                 operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --symbolmap                                   (alias for print-function-map)
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --table64-lowering                            alias for memory64-lowering
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --trace-calls                                 instrument the build with code
-;; CHECK-NEXT:                                                 to intercept specific function
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --tail-call                                   convert calls in tail position 
+;; CHECK-NEXT:                                                 to return calls
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --trace-calls                                 instrument the build with code 
+;; CHECK-NEXT:                                                 to intercept specific function 
 ;; CHECK-NEXT:                                                 calls
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --translate-to-exnref                         translate old Phase 3 EH
-;; CHECK-NEXT:                                                 instructions to new ones with
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --translate-to-exnref                         translate old Phase 3 EH 
+;; CHECK-NEXT:                                                 instructions to new ones with 
 ;; CHECK-NEXT:                                                 exnref
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --translate-to-new-eh                         deprecated; same as
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --translate-to-new-eh                         deprecated; same as 
 ;; CHECK-NEXT:                                                 translate-to-exnref
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --trap-mode-clamp                             replace trapping operations with
-;; CHECK-NEXT:                                                 clamping semantics
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --trap-mode-js                                replace trapping operations with
-;; CHECK-NEXT:                                                 js semantics
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --tuple-optimization                          optimize trivial tuples away
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --type-finalizing                             mark all leaf types as final
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --type-merging                                merge types to their supertypes
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --type-merging                                merge types to their supertypes 
 ;; CHECK-NEXT:                                                 where possible
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --type-refining                               apply more specific subtypes to
-;; CHECK-NEXT:                                                 type fields where possible
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --type-refining-gufa                          apply more specific subtypes to
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --type-refining                               apply more specific subtypes to 
 ;; CHECK-NEXT:                                                 type fields where possible
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --type-refining-gufa                          apply more specific subtypes to 
+;; CHECK-NEXT:                                                 type fields where possible 
 ;; CHECK-NEXT:                                                 (using GUFA)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --type-ssa                                    create new types to help other
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --type-ssa                                    create new types to help other 
 ;; CHECK-NEXT:                                                 optimizations
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --type-unfinalizing                           mark all types as non-final
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --type-unfinalizing                           mark all types as non-final 
 ;; CHECK-NEXT:                                                 (open)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --unsubtyping                                 removes unnecessary subtyping
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --unsubtyping                                 removes unnecessary subtyping 
 ;; CHECK-NEXT:                                                 relationships
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --untee                                       removes local.tees, replacing
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --untee                                       removes local.tees, replacing 
 ;; CHECK-NEXT:                                                 them with sets and gets
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --vacuum                                      removes obviously unneeded code
-;; CHECK-NEXT:
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT: Optimization options:
 ;; CHECK-NEXT: ---------------------
-;; CHECK-NEXT:
-;; CHECK-NEXT:    -O                                           execute default optimization
+;; CHECK-EMPTY:
+;; CHECK-NEXT:    -O                                           execute default optimization 
 ;; CHECK-NEXT:                                                 passes (equivalent to -Os)
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:    -O0                                          execute no optimization passes
-;; CHECK-NEXT:
-;; CHECK-NEXT:    -O1                                          execute -O1 optimization passes
-;; CHECK-NEXT:                                                 (quick&useful opts, useful for
+;; CHECK-EMPTY:
+;; CHECK-NEXT:    -O1                                          execute -O1 optimization passes 
+;; CHECK-NEXT:                                                 (quick&useful opts, useful for 
 ;; CHECK-NEXT:                                                 iteration builds)
-;; CHECK-NEXT:
-;; CHECK-NEXT:    -O2                                          execute -O2 optimization passes
-;; CHECK-NEXT:                                                 (most opts, generally gets most
+;; CHECK-EMPTY:
+;; CHECK-NEXT:    -O2                                          execute -O2 optimization passes 
+;; CHECK-NEXT:                                                 (most opts, generally gets most 
 ;; CHECK-NEXT:                                                 perf)
-;; CHECK-NEXT:
-;; CHECK-NEXT:    -O3                                          execute -O3 optimization passes
-;; CHECK-NEXT:                                                 (spends potentially a lot of
+;; CHECK-EMPTY:
+;; CHECK-NEXT:    -O3                                          execute -O3 optimization passes 
+;; CHECK-NEXT:                                                 (spends potentially a lot of 
 ;; CHECK-NEXT:                                                 time optimizing)
-;; CHECK-NEXT:
-;; CHECK-NEXT:    -O4                                          execute -O4 optimization passes
-;; CHECK-NEXT:                                                 (also flatten the IR, which can
+;; CHECK-EMPTY:
+;; CHECK-NEXT:    -O4                                          execute -O4 optimization passes 
+;; CHECK-NEXT:                                                 (also flatten the IR, which can 
 ;; CHECK-NEXT:                                                 take a lot more time and memory,
-;; CHECK-NEXT:                                                 but is useful on more nested /
+;; CHECK-NEXT:                                                 but is useful on more nested / 
 ;; CHECK-NEXT:                                                 complex / less-optimized input)
-;; CHECK-NEXT:
-;; CHECK-NEXT:    -Os                                          execute default optimization
+;; CHECK-EMPTY:
+;; CHECK-NEXT:    -Os                                          execute default optimization 
 ;; CHECK-NEXT:                                                 passes, focusing on code size
-;; CHECK-NEXT:
-;; CHECK-NEXT:    -Oz                                          execute default optimization
-;; CHECK-NEXT:                                                 passes, super-focusing on code
+;; CHECK-EMPTY:
+;; CHECK-NEXT:    -Oz                                          execute default optimization 
+;; CHECK-NEXT:                                                 passes, super-focusing on code 
 ;; CHECK-NEXT:                                                 size
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --optimize-level,-ol                          How much to focus on optimizing
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --optimize-level,-ol                          How much to focus on optimizing 
 ;; CHECK-NEXT:                                                 code
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --shrink-level,-s                             How much to focus on shrinking
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --shrink-level,-s                             How much to focus on shrinking 
 ;; CHECK-NEXT:                                                 code size
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --debuginfo,-g                                Emit names section in wasm
-;; CHECK-NEXT:                                                 binary (or full debuginfo in
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --debuginfo,-g                                Emit names section in wasm 
+;; CHECK-NEXT:                                                 binary (or full debuginfo in 
 ;; CHECK-NEXT:                                                 wast)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --always-inline-max-function-size,-aimfs      Max size of functions that are
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --always-inline-max-function-size,-aimfs      Max size of functions that are 
 ;; CHECK-NEXT:                                                 always inlined (default 2, which
 ;; CHECK-NEXT:                                                 is safe for use with -Os builds)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --flexible-inline-max-function-size,-fimfs    Max size of functions that are
-;; CHECK-NEXT:                                                 inlined when lightweight (no
-;; CHECK-NEXT:                                                 loops or function calls) when
-;; CHECK-NEXT:                                                 optimizing aggressively for
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --flexible-inline-max-function-size,-fimfs    Max size of functions that are 
+;; CHECK-NEXT:                                                 inlined when lightweight (no 
+;; CHECK-NEXT:                                                 loops or function calls) when 
+;; CHECK-NEXT:                                                 optimizing aggressively for 
 ;; CHECK-NEXT:                                                 speed (-O3). Default: 20
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --one-caller-inline-max-function-size,-ocimfs Max size of functions that are
-;; CHECK-NEXT:                                                 inlined when there is only one
-;; CHECK-NEXT:                                                 caller (default -1, which means
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --one-caller-inline-max-function-size,-ocimfs Max size of functions that are 
+;; CHECK-NEXT:                                                 inlined when there is only one 
+;; CHECK-NEXT:                                                 caller (default -1, which means 
 ;; CHECK-NEXT:                                                 all such functions are inlined)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --inline-max-combined-binary-size,-imcbs      Max size of combined functions
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --inline-max-combined-binary-size,-imcbs      Max size of combined functions 
 ;; CHECK-NEXT:                                                 after inlining. Default: 409600
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --inline-functions-with-loops,-ifwl           Allow inlining functions with
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --inline-functions-with-loops,-ifwl           Allow inlining functions with 
 ;; CHECK-NEXT:                                                 loops
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --partial-inlining-ifs,-pii                   Number of ifs allowed in partial
-;; CHECK-NEXT:                                                 inlining (zero means partial
-;; CHECK-NEXT:                                                 inlining is disabled) (default:
+;; CHECK-NEXT:                                                 inlining (zero means partial 
+;; CHECK-NEXT:                                                 inlining is disabled) (default: 
 ;; CHECK-NEXT:                                                 0)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --ignore-implicit-traps,-iit                  Optimize under the helpful
-;; CHECK-NEXT:                                                 assumption that no surprising
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --ignore-implicit-traps,-iit                  Optimize under the helpful 
+;; CHECK-NEXT:                                                 assumption that no surprising 
 ;; CHECK-NEXT:                                                 traps occur (from load, div/mod,
 ;; CHECK-NEXT:                                                 etc.)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --traps-never-happen,-tnh                     Optimize under the helpful
-;; CHECK-NEXT:                                                 assumption that no trap is
-;; CHECK-NEXT:                                                 reached at runtime (from load,
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --traps-never-happen,-tnh                     Optimize under the helpful 
+;; CHECK-NEXT:                                                 assumption that no trap is 
+;; CHECK-NEXT:                                                 reached at runtime (from load, 
 ;; CHECK-NEXT:                                                 div/mod, etc.)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --low-memory-unused,-lmu                      Optimize under the helpful
-;; CHECK-NEXT:                                                 assumption that the low 1K of
-;; CHECK-NEXT:                                                 memory is not used by the
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --low-memory-unused,-lmu                      Optimize under the helpful 
+;; CHECK-NEXT:                                                 assumption that the low 1K of 
+;; CHECK-NEXT:                                                 memory is not used by the 
 ;; CHECK-NEXT:                                                 application
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --fast-math,-ffm                              Optimize floats without handling
-;; CHECK-NEXT:                                                 corner cases of NaNs and
-;; CHECK-NEXT:                                                 rounding
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --zero-filled-memory,-uim                     Assume that an imported memory
+;; CHECK-NEXT:                                                 corner cases of NaNs, rounding, 
+;; CHECK-NEXT:                                                 and negative zero
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --zero-filled-memory,-uim                     Assume that an imported memory 
 ;; CHECK-NEXT:                                                 will be zero-initialized
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --skip-pass,-sp                               Skip a pass (do not run it)
-;; CHECK-NEXT:
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT: Tool options:
 ;; CHECK-NEXT: -------------
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --mvp-features,-mvp                           Disable all non-MVP features
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --all-features,-all                           Enable all features
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --detect-features                             (deprecated - this flag does
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --detect-features                             (deprecated - this flag does 
 ;; CHECK-NEXT:                                                 nothing)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --quiet,-q                                    Emit less verbose output and
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --quiet,-q                                    Emit less verbose output and 
 ;; CHECK-NEXT:                                                 hide trivial warnings.
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --experimental-poppy                          Parse wast files as Poppy IR for
 ;; CHECK-NEXT:                                                 testing purposes.
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --emit-module-names                           Emit module names, even if not
-;; CHECK-NEXT:                                                 emitting the rest of the names
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --emit-module-names                           Emit module names, even if not 
+;; CHECK-NEXT:                                                 emitting the rest of the names 
 ;; CHECK-NEXT:                                                 section.
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-sign-ext                             Enable sign extension operations
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --disable-sign-ext                            Disable sign extension
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --disable-sign-ext                            Disable sign extension 
 ;; CHECK-NEXT:                                                 operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-threads                              Enable atomic operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-threads                             Disable atomic operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-mutable-globals                      Enable mutable globals
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-mutable-globals                     Disable mutable globals
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --enable-nontrapping-float-to-int             Enable nontrapping float-to-int
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --enable-nontrapping-float-to-int             Enable nontrapping float-to-int 
 ;; CHECK-NEXT:                                                 operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-nontrapping-float-to-int            Disable nontrapping float-to-int
 ;; CHECK-NEXT:                                                 operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-simd                                 Enable SIMD operations and types
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --disable-simd                                Disable SIMD operations and
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --disable-simd                                Disable SIMD operations and 
 ;; CHECK-NEXT:                                                 types
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-bulk-memory                          Enable bulk memory operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-bulk-memory                         Disable bulk memory operations
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --enable-bulk-memory-opt                      Enable memory.copy and
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --enable-bulk-memory-opt                      Enable memory.copy and 
 ;; CHECK-NEXT:                                                 memory.fill
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --disable-bulk-memory-opt                     Disable memory.copy and
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --disable-bulk-memory-opt                     Disable memory.copy and 
 ;; CHECK-NEXT:                                                 memory.fill
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --enable-call-indirect-overlong               Enable LEB encoding of
-;; CHECK-NEXT:                                                 call-indirect (Ignored for
-;; CHECK-NEXT:                                                 compatibility as it has no
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --enable-call-indirect-overlong               Enable LEB encoding of 
+;; CHECK-NEXT:                                                 call-indirect (Ignored for 
+;; CHECK-NEXT:                                                 compatibility as it has no 
 ;; CHECK-NEXT:                                                 effect on Binaryen)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --disable-call-indirect-overlong              Disable LEB encoding of
-;; CHECK-NEXT:                                                 call-indirect (Ignored for
-;; CHECK-NEXT:                                                 compatibility as it has no
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --disable-call-indirect-overlong              Disable LEB encoding of 
+;; CHECK-NEXT:                                                 call-indirect (Ignored for 
+;; CHECK-NEXT:                                                 compatibility as it has no 
 ;; CHECK-NEXT:                                                 effect on Binaryen)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --enable-exception-handling                   Enable exception handling
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --enable-exception-handling                   Enable exception handling 
 ;; CHECK-NEXT:                                                 operations
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --disable-exception-handling                  Disable exception handling
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --disable-exception-handling                  Disable exception handling 
 ;; CHECK-NEXT:                                                 operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-tail-call                            Enable tail call operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-tail-call                           Disable tail call operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-reference-types                      Enable reference types
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-reference-types                     Disable reference types
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-multivalue                           Enable multivalue functions
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-multivalue                          Disable multivalue functions
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-gc                                   Enable garbage collection
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-gc                                  Disable garbage collection
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-memory64                             Enable memory64
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-memory64                            Disable memory64
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-relaxed-simd                         Enable relaxed SIMD
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-relaxed-simd                        Disable relaxed SIMD
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --enable-extended-const                       Enable extended const
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --enable-extended-const                       Enable extended const 
 ;; CHECK-NEXT:                                                 expressions
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --disable-extended-const                      Disable extended const
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --disable-extended-const                      Disable extended const 
 ;; CHECK-NEXT:                                                 expressions
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-strings                              Enable strings
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-strings                             Disable strings
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-multimemory                          Enable multimemory
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-multimemory                         Disable multimemory
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-stack-switching                      Enable stack switching
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-stack-switching                     Disable stack switching
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-shared-everything                    Enable shared-everything threads
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --disable-shared-everything                   Disable shared-everything
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --disable-shared-everything                   Disable shared-everything 
 ;; CHECK-NEXT:                                                 threads
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-fp16                                 Enable float 16 operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-fp16                                Disable float 16 operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-custom-descriptors                   Enable custom descriptors (RTTs)
 ;; CHECK-NEXT:                                                 and exact references
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --disable-custom-descriptors                  Disable custom descriptors
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --disable-custom-descriptors                  Disable custom descriptors 
 ;; CHECK-NEXT:                                                 (RTTs) and exact references
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-multibyte                            Enable multibyte array loads and
 ;; CHECK-NEXT:                                                 stores
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --disable-multibyte                           Disable multibyte array loads
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --disable-multibyte                           Disable multibyte array loads 
 ;; CHECK-NEXT:                                                 and stores
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --enable-acquire-release-atomics              Enable acquire/release atomic
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --enable-acquire-release-atomics              Enable acquire/release atomic 
 ;; CHECK-NEXT:                                                 memory operations
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --disable-acquire-release-atomics             Disable acquire/release atomic
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --disable-acquire-release-atomics             Disable acquire/release atomic 
 ;; CHECK-NEXT:                                                 memory operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-custom-page-sizes                    Enable custom page sizes
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-custom-page-sizes                   Disable custom page sizes
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-wide-arithmetic                      Enable wide arithmetic
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-wide-arithmetic                     Disable wide arithmetic
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-compact-imports                      Enable compact import section
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-compact-imports                     Disable compact import section
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --enable-relaxed-atomics                      Enable relaxed atomic memory
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --enable-relaxed-atomics                      Enable relaxed atomic memory 
 ;; CHECK-NEXT:                                                 operations
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --disable-relaxed-atomics                     Disable relaxed atomic memory
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --disable-relaxed-atomics                     Disable relaxed atomic memory 
 ;; CHECK-NEXT:                                                 operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-typed-function-references            Deprecated compatibility flag
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-typed-function-references           Deprecated compatibility flag
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --no-validation,-n                            Disables validation, assumes
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --no-validation,-n                            Disables validation, assumes 
 ;; CHECK-NEXT:                                                 inputs are correct
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --pass-arg,-pa                                An argument passed along to
-;; CHECK-NEXT:                                                 optimization passes being run.
-;; CHECK-NEXT:                                                 Must be in the form KEY@VALUE.
-;; CHECK-NEXT:                                                 If KEY is the name of a pass
-;; CHECK-NEXT:                                                 then it applies to the closest
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --pass-arg,-pa                                An argument passed along to 
+;; CHECK-NEXT:                                                 optimization passes being run. 
+;; CHECK-NEXT:                                                 Must be in the form KEY@VALUE.  
+;; CHECK-NEXT:                                                 If KEY is the name of a pass 
+;; CHECK-NEXT:                                                 then it applies to the closest 
 ;; CHECK-NEXT:                                                 instance of that pass before us.
 ;; CHECK-NEXT:                                                 If KEY is not the name of a pass
-;; CHECK-NEXT:                                                 then it is a global option that
-;; CHECK-NEXT:                                                 applies to all pass instances
+;; CHECK-NEXT:                                                 then it is a global option that 
+;; CHECK-NEXT:                                                 applies to all pass instances 
 ;; CHECK-NEXT:                                                 that read it.
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --closed-world,-cw                            Assume code outside of the
-;; CHECK-NEXT:                                                 module does not inspect or
-;; CHECK-NEXT:                                                 interact with GC and function
-;; CHECK-NEXT:                                                 references, even if they are
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --closed-world,-cw                            Assume code outside of the 
+;; CHECK-NEXT:                                                 module does not inspect or 
+;; CHECK-NEXT:                                                 interact with GC and function 
+;; CHECK-NEXT:                                                 references, even if they are 
 ;; CHECK-NEXT:                                                 passed out. The outside may hold
-;; CHECK-NEXT:                                                 on to them and pass them back
-;; CHECK-NEXT:                                                 in, but not inspect their
+;; CHECK-NEXT:                                                 on to them and pass them back 
+;; CHECK-NEXT:                                                 in, but not inspect their 
 ;; CHECK-NEXT:                                                 contents or call them.
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --preserve-type-order                         Preserve the order of types from
-;; CHECK-NEXT:                                                 the input (useful for debugging
+;; CHECK-NEXT:                                                 the input (useful for debugging 
 ;; CHECK-NEXT:                                                 and testing)
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --generate-stack-ir                           generate StackIR during writing
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --optimize-stack-ir                           optimize StackIR during writing
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --print-stack-ir                              print StackIR during writing
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --no-stack-ir                                 do not use StackIR (even when it
 ;; CHECK-NEXT:                                                 is the default)
-;; CHECK-NEXT:
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT: General options:
 ;; CHECK-NEXT: ----------------
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --version                                     Output version information and
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --version                                     Output version information and 
 ;; CHECK-NEXT:                                                 exit
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --help,-h                                     Show this help message and exit
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --debug,-d                                    Print debug information to
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --debug,-d                                    Print debug information to 
 ;; CHECK-NEXT:                                                 stderr
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
diff --git a/test/lit/help/wasm-reduce.test b/test/lit/help/wasm-reduce.test
index ce4dc9c11d7..20a2575a81e 100644
--- a/test/lit/help/wasm-reduce.test
+++ b/test/lit/help/wasm-reduce.test
@@ -1,13 +1,13 @@
 ;; RUN: wasm-reduce --help | filecheck %s
 ;; CHECK: ================================================================================
 ;; CHECK-NEXT: wasm-reduce INFILE
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT: Reduce a wasm file to a smaller one with the same behavior on a given command.
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT: Typical usage:
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   wasm-reduce orig.wasm '--command=bash a.sh' --test t.wasm --working w.wasm
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT: The original file orig.wasm is where we begin. We then repeatedly test a small
 ;; CHECK-NEXT: reduction of it by writing that modification to the 'test file' (specified by
 ;; CHECK-NEXT: '--test'), and we run the command, in this example 'bash a.sh'. That command
@@ -18,21 +18,21 @@
 ;; CHECK-NEXT: same stdout and the result return code. Each time reduction works we continue to
 ;; CHECK-NEXT: reduce from that point (and each time it fails, we go back and try something
 ;; CHECK-NEXT: else).
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT: As mentioned above, the command should run on the test file. That is, the first
 ;; CHECK-NEXT: thing that wasm-reduce does on the example above is, effectively,
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   cp orig.wasm t.wasm
 ;; CHECK-NEXT:   bash a.sh
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT: In other words, it copies the original to the test file, and runs the command.
 ;; CHECK-NEXT: Whatever the command does, we will preserve as we copy progressively smaller
 ;; CHECK-NEXT: files to t.wasm. As we make progress, the smallest file will be written to
 ;; CHECK-NEXT: the working file, w.wasm, and when reduction is done you will find the final
 ;; CHECK-NEXT: result there.
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT: Comparison to creduce:
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT: 1. creduce requires the command to return 0. wasm-reduce is often used to reduce
 ;; CHECK-NEXT:    crashes, which have non-zero return codes, so it is natural to allow any
 ;; CHECK-NEXT:    return code. As mentioned above, we preserve the return code as we reduce.
@@ -50,241 +50,241 @@
 ;; CHECK-NEXT:    the testcase is a combination of JavaScript and wasm). wasm-reduce runs the
 ;; CHECK-NEXT:    command in the current directory (of course, your command can be a script
 ;; CHECK-NEXT:    that changes directory to anywhere else).
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT: More documentation can be found at
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   https://github.com/WebAssembly/binaryen/wiki/Fuzzing#reducing
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT: ================================================================================
-;; CHECK-NEXT:
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT: wasm-reduce options:
 ;; CHECK-NEXT: --------------------
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --command,-cmd                       The command to run on the test, that we
-;; CHECK-NEXT:                                        want to reduce while keeping the
-;; CHECK-NEXT:                                        command's output identical. We look at
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --command,-cmd                       The command to run on the test, that we 
+;; CHECK-NEXT:                                        want to reduce while keeping the 
+;; CHECK-NEXT:                                        command's output identical. We look at 
 ;; CHECK-NEXT:                                        the command's return code and stdout here
-;; CHECK-NEXT:                                        (TODO: stderr), and we reduce while
+;; CHECK-NEXT:                                        (TODO: stderr), and we reduce while 
 ;; CHECK-NEXT:                                        keeping those unchanged.
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --test,-t                            Test file (this will be written to test,
-;; CHECK-NEXT:                                        the given command should read it when we
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --test,-t                            Test file (this will be written to test, 
+;; CHECK-NEXT:                                        the given command should read it when we 
 ;; CHECK-NEXT:                                        call it)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --working,-w                         Working file (this will contain the
-;; CHECK-NEXT:                                        current good state while doing temporary
-;; CHECK-NEXT:                                        computations, and will contain the final
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --working,-w                         Working file (this will contain the 
+;; CHECK-NEXT:                                        current good state while doing temporary 
+;; CHECK-NEXT:                                        computations, and will contain the final 
 ;; CHECK-NEXT:                                        best result at the end)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --binaries,-b                        binaryen binaries location (bin/
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --binaries,-b                        binaryen binaries location (bin/ 
 ;; CHECK-NEXT:                                        directory)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --text,-S                            Emit intermediate files as text, instead
-;; CHECK-NEXT:                                        of binary (also make sure the test and
-;; CHECK-NEXT:                                        working files have a .wat or .wast
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --text,-S                            Emit intermediate files as text, instead 
+;; CHECK-NEXT:                                        of binary (also make sure the test and 
+;; CHECK-NEXT:                                        working files have a .wat or .wast 
 ;; CHECK-NEXT:                                        suffix)
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --denan                              Avoid nans when reducing
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --verbose,-v                         Verbose output mode
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --debugInfo,-g                       Keep debug info in binaries
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --force,-f                           Force the reduction attempt, ignoring
-;; CHECK-NEXT:                                        problems that imply it is unlikely to
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --force,-f                           Force the reduction attempt, ignoring 
+;; CHECK-NEXT:                                        problems that imply it is unlikely to 
 ;; CHECK-NEXT:                                        succeed
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --timeout,-to                        A timeout to apply to each execution of
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --timeout,-to                        A timeout to apply to each execution of 
 ;; CHECK-NEXT:                                        the command, in seconds (default: 2)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --extra-flags,-ef                    Extra commandline flags to pass to
-;; CHECK-NEXT:                                        wasm-opt while reducing. (default:
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --extra-flags,-ef                    Extra commandline flags to pass to 
+;; CHECK-NEXT:                                        wasm-opt while reducing. (default: 
 ;; CHECK-NEXT:                                        --enable-all)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --save-all-working,-saw              Save all intermediate working files, as
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --save-all-working,-saw              Save all intermediate working files, as 
 ;; CHECK-NEXT:                                        $WORKING.0, .1, .2 etc
-;; CHECK-NEXT:
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT: Tool options:
 ;; CHECK-NEXT: -------------
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --mvp-features,-mvp                  Disable all non-MVP features
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --all-features,-all                  Enable all features
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --detect-features                    (deprecated - this flag does nothing)
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --quiet,-q                           Emit less verbose output and hide trivial
 ;; CHECK-NEXT:                                        warnings.
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --experimental-poppy                 Parse wast files as Poppy IR for testing
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --experimental-poppy                 Parse wast files as Poppy IR for testing 
 ;; CHECK-NEXT:                                        purposes.
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --emit-module-names                  Emit module names, even if not emitting
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --emit-module-names                  Emit module names, even if not emitting 
 ;; CHECK-NEXT:                                        the rest of the names section.
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-sign-ext                    Enable sign extension operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-sign-ext                   Disable sign extension operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-threads                     Enable atomic operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-threads                    Disable atomic operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-mutable-globals             Enable mutable globals
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-mutable-globals            Disable mutable globals
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --enable-nontrapping-float-to-int    Enable nontrapping float-to-int
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --enable-nontrapping-float-to-int    Enable nontrapping float-to-int 
 ;; CHECK-NEXT:                                        operations
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --disable-nontrapping-float-to-int   Disable nontrapping float-to-int
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --disable-nontrapping-float-to-int   Disable nontrapping float-to-int 
 ;; CHECK-NEXT:                                        operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-simd                        Enable SIMD operations and types
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-simd                       Disable SIMD operations and types
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-bulk-memory                 Enable bulk memory operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-bulk-memory                Disable bulk memory operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-bulk-memory-opt             Enable memory.copy and memory.fill
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-bulk-memory-opt            Disable memory.copy and memory.fill
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --enable-call-indirect-overlong      Enable LEB encoding of call-indirect
-;; CHECK-NEXT:                                        (Ignored for compatibility as it has no
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --enable-call-indirect-overlong      Enable LEB encoding of call-indirect 
+;; CHECK-NEXT:                                        (Ignored for compatibility as it has no 
 ;; CHECK-NEXT:                                        effect on Binaryen)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --disable-call-indirect-overlong     Disable LEB encoding of call-indirect
-;; CHECK-NEXT:                                        (Ignored for compatibility as it has no
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --disable-call-indirect-overlong     Disable LEB encoding of call-indirect 
+;; CHECK-NEXT:                                        (Ignored for compatibility as it has no 
 ;; CHECK-NEXT:                                        effect on Binaryen)
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-exception-handling          Enable exception handling operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-exception-handling         Disable exception handling operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-tail-call                   Enable tail call operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-tail-call                  Disable tail call operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-reference-types             Enable reference types
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-reference-types            Disable reference types
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-multivalue                  Enable multivalue functions
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-multivalue                 Disable multivalue functions
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-gc                          Enable garbage collection
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-gc                         Disable garbage collection
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-memory64                    Enable memory64
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-memory64                   Disable memory64
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-relaxed-simd                Enable relaxed SIMD
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-relaxed-simd               Disable relaxed SIMD
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-extended-const              Enable extended const expressions
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-extended-const             Disable extended const expressions
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-strings                     Enable strings
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-strings                    Disable strings
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-multimemory                 Enable multimemory
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-multimemory                Disable multimemory
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-stack-switching             Enable stack switching
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-stack-switching            Disable stack switching
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-shared-everything           Enable shared-everything threads
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-shared-everything          Disable shared-everything threads
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-fp16                        Enable float 16 operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-fp16                       Disable float 16 operations
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --enable-custom-descriptors          Enable custom descriptors (RTTs) and
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --enable-custom-descriptors          Enable custom descriptors (RTTs) and 
 ;; CHECK-NEXT:                                        exact references
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --disable-custom-descriptors         Disable custom descriptors (RTTs) and
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --disable-custom-descriptors         Disable custom descriptors (RTTs) and 
 ;; CHECK-NEXT:                                        exact references
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-multibyte                   Enable multibyte array loads and stores
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-multibyte                  Disable multibyte array loads and stores
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --enable-acquire-release-atomics     Enable acquire/release atomic memory
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --enable-acquire-release-atomics     Enable acquire/release atomic memory 
 ;; CHECK-NEXT:                                        operations
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --disable-acquire-release-atomics    Disable acquire/release atomic memory
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --disable-acquire-release-atomics    Disable acquire/release atomic memory 
 ;; CHECK-NEXT:                                        operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-custom-page-sizes           Enable custom page sizes
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-custom-page-sizes          Disable custom page sizes
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-wide-arithmetic             Enable wide arithmetic
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-wide-arithmetic            Disable wide arithmetic
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-compact-imports             Enable compact import section
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-compact-imports            Disable compact import section
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-relaxed-atomics             Enable relaxed atomic memory operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-relaxed-atomics            Disable relaxed atomic memory operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-typed-function-references   Deprecated compatibility flag
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-typed-function-references  Deprecated compatibility flag
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --no-validation,-n                   Disables validation, assumes inputs are
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --no-validation,-n                   Disables validation, assumes inputs are 
 ;; CHECK-NEXT:                                        correct
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --pass-arg,-pa                       An argument passed along to optimization
-;; CHECK-NEXT:                                        passes being run. Must be in the form
-;; CHECK-NEXT:                                        KEY@VALUE.  If KEY is the name of a pass
-;; CHECK-NEXT:                                        then it applies to the closest instance
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --pass-arg,-pa                       An argument passed along to optimization 
+;; CHECK-NEXT:                                        passes being run. Must be in the form 
+;; CHECK-NEXT:                                        KEY@VALUE.  If KEY is the name of a pass 
+;; CHECK-NEXT:                                        then it applies to the closest instance 
 ;; CHECK-NEXT:                                        of that pass before us. If KEY is not the
 ;; CHECK-NEXT:                                        name of a pass then it is a global option
-;; CHECK-NEXT:                                        that applies to all pass instances that
+;; CHECK-NEXT:                                        that applies to all pass instances that 
 ;; CHECK-NEXT:                                        read it.
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --closed-world,-cw                   Assume code outside of the module does
-;; CHECK-NEXT:                                        not inspect or interact with GC and
-;; CHECK-NEXT:                                        function references, even if they are
-;; CHECK-NEXT:                                        passed out. The outside may hold on to
-;; CHECK-NEXT:                                        them and pass them back in, but not
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --closed-world,-cw                   Assume code outside of the module does 
+;; CHECK-NEXT:                                        not inspect or interact with GC and 
+;; CHECK-NEXT:                                        function references, even if they are 
+;; CHECK-NEXT:                                        passed out. The outside may hold on to 
+;; CHECK-NEXT:                                        them and pass them back in, but not 
 ;; CHECK-NEXT:                                        inspect their contents or call them.
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --preserve-type-order                Preserve the order of types from the
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --preserve-type-order                Preserve the order of types from the 
 ;; CHECK-NEXT:                                        input (useful for debugging and testing)
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --generate-stack-ir                  generate StackIR during writing
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --optimize-stack-ir                  optimize StackIR during writing
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --print-stack-ir                     print StackIR during writing
-;; CHECK-NEXT:
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT: General options:
 ;; CHECK-NEXT: ----------------
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --version                            Output version information and exit
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --help,-h                            Show this help message and exit
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --debug,-d                           Print debug information to stderr
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
diff --git a/test/lit/help/wasm-shell.test b/test/lit/help/wasm-shell.test
index 8214c06f923..b9e01dad52a 100644
--- a/test/lit/help/wasm-shell.test
+++ b/test/lit/help/wasm-shell.test
@@ -1,17 +1,17 @@
 ;; RUN: wasm-shell --help | filecheck %s
 ;; CHECK: ================================================================================
 ;; CHECK-NEXT: wasm-shell INFILE
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT: Execute .wast files
 ;; CHECK-NEXT: ================================================================================
-;; CHECK-NEXT:
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT: General options:
 ;; CHECK-NEXT: ----------------
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --version  Output version information and exit
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --help,-h  Show this help message and exit
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --debug,-d Print debug information to stderr
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
diff --git a/test/lit/help/wasm-split.test b/test/lit/help/wasm-split.test
index 9d8079ed283..542a8b3c382 100644
--- a/test/lit/help/wasm-split.test
+++ b/test/lit/help/wasm-split.test
@@ -1,339 +1,339 @@
 ;; RUN: wasm-split --help | filecheck %s
 ;; CHECK: ================================================================================
 ;; CHECK-NEXT: wasm-split INFILES
-;; CHECK-NEXT:
-;; CHECK-NEXT: Split a module into a primary module and a secondary module, or instrument a
-;; CHECK-NEXT: module to gather a profile that can inform future splitting, or manage such
+;; CHECK-EMPTY:
+;; CHECK-NEXT: Split a module into a primary module and a secondary module, or instrument a 
+;; CHECK-NEXT: module to gather a profile that can inform future splitting, or manage such 
 ;; CHECK-NEXT: profiles. Options that are only accepted in particular modes are marked with the
 ;; CHECK-NEXT: accepted "[<modes>]" in their descriptions.
 ;; CHECK-NEXT: ================================================================================
-;; CHECK-NEXT:
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT: wasm-split options:
 ;; CHECK-NEXT: -------------------
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --split                              Split an input module into two output
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --split                              Split an input module into two output 
 ;; CHECK-NEXT:                                        modules. The default mode.
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --multi-split                        Split an input module into an arbitrary
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --multi-split                        Split an input module into an arbitrary 
 ;; CHECK-NEXT:                                        number of output modules.
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --instrument                         Instrument an input module to allow it to
-;; CHECK-NEXT:                                        generate a profile that can be used to
+;; CHECK-NEXT:                                        generate a profile that can be used to 
 ;; CHECK-NEXT:                                        guide splitting.
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --merge-profiles                     Merge multiple profiles for the same
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --merge-profiles                     Merge multiple profiles for the same 
 ;; CHECK-NEXT:                                        module into a single profile.
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --print-profile                      [print-profile] Print profile contents in
 ;; CHECK-NEXT:                                        a human-readable format.
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --profile                            [split] The profile to use to guide
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --profile                            [split] The profile to use to guide 
 ;; CHECK-NEXT:                                        splitting.
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --keep-funcs                         [split] Comma-separated list of functions
-;; CHECK-NEXT:                                        to keep in the primary module. The rest
-;; CHECK-NEXT:                                        will be split out. Can be used alongside
+;; CHECK-NEXT:                                        to keep in the primary module. The rest 
+;; CHECK-NEXT:                                        will be split out. Can be used alongside 
 ;; CHECK-NEXT:                                        --profile and --split-funcs. You can also
 ;; CHECK-NEXT:                                        pass a file with one function per line by
 ;; CHECK-NEXT:                                        passing @filename.
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --split-funcs                        [split] Comma-separated list of functions
 ;; CHECK-NEXT:                                        to split out to the secondary module. The
-;; CHECK-NEXT:                                        rest will be kept. Can be used alongside
-;; CHECK-NEXT:                                        --profile and --keep-funcs. This takes
-;; CHECK-NEXT:                                        precedence over other split options. You
-;; CHECK-NEXT:                                        can also pass a file with one function
+;; CHECK-NEXT:                                        rest will be kept. Can be used alongside 
+;; CHECK-NEXT:                                        --profile and --keep-funcs. This takes 
+;; CHECK-NEXT:                                        precedence over other split options. You 
+;; CHECK-NEXT:                                        can also pass a file with one function 
 ;; CHECK-NEXT:                                        per line by passing @filename.
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --manifest                           [multi-split] File describing the
-;; CHECK-NEXT:                                        functions to be split into each module.
-;; CHECK-NEXT:                                        Each section separated by a blank line
-;; CHECK-NEXT:                                        begins with the base name of an output
-;; CHECK-NEXT:                                        module, which is followed by a list of
-;; CHECK-NEXT:                                        functions to place in that module, one
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --manifest                           [multi-split] File describing the 
+;; CHECK-NEXT:                                        functions to be split into each module. 
+;; CHECK-NEXT:                                        Each section separated by a blank line 
+;; CHECK-NEXT:                                        begins with the base name of an output 
+;; CHECK-NEXT:                                        module, which is followed by a list of 
+;; CHECK-NEXT:                                        functions to place in that module, one 
 ;; CHECK-NEXT:                                        per line.
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --out-prefix                         [multi-split] Prefix prepended to module
-;; CHECK-NEXT:                                        names in the manifest file to create
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --out-prefix                         [multi-split] Prefix prepended to module 
+;; CHECK-NEXT:                                        names in the manifest file to create 
 ;; CHECK-NEXT:                                        output file names.
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --primary-output,-o1                 [split] Output file for the primary
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --primary-output,-o1                 [split] Output file for the primary 
 ;; CHECK-NEXT:                                        module.
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --secondary-output,-o2               [split] Output file for the secondary
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --secondary-output,-o2               [split] Output file for the secondary 
 ;; CHECK-NEXT:                                        module.
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --symbolmap                          [split, multi-split] Write a symbol map
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --symbolmap                          [split, multi-split] Write a symbol map 
 ;; CHECK-NEXT:                                        file for each of the output modules.
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --no-placeholders                    [split, multi-split] Do not import
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --no-placeholders                    [split, multi-split] Do not import 
 ;; CHECK-NEXT:                                        placeholder functions. Calls to secondary
-;; CHECK-NEXT:                                        functions will fail before the secondary
+;; CHECK-NEXT:                                        functions will fail before the secondary 
 ;; CHECK-NEXT:                                        module has been instantiated.
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --placeholdermap                     [split, multi-split] Write a file mapping
-;; CHECK-NEXT:                                        placeholder indices to the function
+;; CHECK-NEXT:                                        placeholder indices to the function 
 ;; CHECK-NEXT:                                        names.
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --import-namespace                   [split, multi-split, instrument] When
-;; CHECK-NEXT:                                        provided as an option for module
-;; CHECK-NEXT:                                        splitting, the namespace from which to
-;; CHECK-NEXT:                                        import objects from the primary module
-;; CHECK-NEXT:                                        into the secondary module. In instrument
-;; CHECK-NEXT:                                        mode, refers to the namespace from which
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --import-namespace                   [split, multi-split, instrument] When 
+;; CHECK-NEXT:                                        provided as an option for module 
+;; CHECK-NEXT:                                        splitting, the namespace from which to 
+;; CHECK-NEXT:                                        import objects from the primary module 
+;; CHECK-NEXT:                                        into the secondary module. In instrument 
+;; CHECK-NEXT:                                        mode, refers to the namespace from which 
 ;; CHECK-NEXT:                                        to import the secondary memory, if any.
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --placeholder-namespace-prefix       [split, multi-split] The prefix for the
-;; CHECK-NEXT:                                        namespaces from which to import
-;; CHECK-NEXT:                                        placeholder functions into the primary
-;; CHECK-NEXT:                                        module. The namespaces will be
-;; CHECK-NEXT:                                        concatenations of the prefix and the
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --placeholder-namespace-prefix       [split, multi-split] The prefix for the 
+;; CHECK-NEXT:                                        namespaces from which to import 
+;; CHECK-NEXT:                                        placeholder functions into the primary 
+;; CHECK-NEXT:                                        module. The namespaces will be 
+;; CHECK-NEXT:                                        concatenations of the prefix and the 
 ;; CHECK-NEXT:                                        module name.
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --placeholder-namespace              [split, multi-split] The same as
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --placeholder-namespace              [split, multi-split] The same as 
 ;; CHECK-NEXT:                                        --placeholder-namespace-prefix.
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --export-prefix                      [split, multi-split] An identifying
-;; CHECK-NEXT:                                        prefix to prepend to new export names
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --export-prefix                      [split, multi-split] An identifying 
+;; CHECK-NEXT:                                        prefix to prepend to new export names 
 ;; CHECK-NEXT:                                        created by module splitting.
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --profile-export                     [instrument] The export name of the
-;; CHECK-NEXT:                                        function the embedder calls to write the
-;; CHECK-NEXT:                                        profile into memory. Defaults to
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --profile-export                     [instrument] The export name of the 
+;; CHECK-NEXT:                                        function the embedder calls to write the 
+;; CHECK-NEXT:                                        profile into memory. Defaults to 
 ;; CHECK-NEXT:                                        `__write_profile`.
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --in-memory                          [instrument] Store profile information in
-;; CHECK-NEXT:                                        memory (starting at address 0 and taking
-;; CHECK-NEXT:                                        one byte per function) rather than
-;; CHECK-NEXT:                                        globals (the default) so that it can be
-;; CHECK-NEXT:                                        shared between multiple threads. Users
-;; CHECK-NEXT:                                        are responsible for ensuring that the
-;; CHECK-NEXT:                                        module does not use the initial memory
+;; CHECK-NEXT:                                        memory (starting at address 0 and taking 
+;; CHECK-NEXT:                                        one byte per function) rather than 
+;; CHECK-NEXT:                                        globals (the default) so that it can be 
+;; CHECK-NEXT:                                        shared between multiple threads. Users 
+;; CHECK-NEXT:                                        are responsible for ensuring that the 
+;; CHECK-NEXT:                                        module does not use the initial memory 
 ;; CHECK-NEXT:                                        region for anything else.
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --in-secondary-memory                [instrument] Store profile information in
-;; CHECK-NEXT:                                        a separate memory, rather than in module
-;; CHECK-NEXT:                                        main memory or globals (the default).
-;; CHECK-NEXT:                                        With this option, users do not need to
-;; CHECK-NEXT:                                        reserve the initial memory region for
-;; CHECK-NEXT:                                        profile data and the data can be shared
+;; CHECK-NEXT:                                        a separate memory, rather than in module 
+;; CHECK-NEXT:                                        main memory or globals (the default). 
+;; CHECK-NEXT:                                        With this option, users do not need to 
+;; CHECK-NEXT:                                        reserve the initial memory region for 
+;; CHECK-NEXT:                                        profile data and the data can be shared 
 ;; CHECK-NEXT:                                        between multiple threads.
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --secondary-memory-name              [instrument] The name of the secondary
-;; CHECK-NEXT:                                        memory created to store profile
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --secondary-memory-name              [instrument] The name of the secondary 
+;; CHECK-NEXT:                                        memory created to store profile 
 ;; CHECK-NEXT:                                        information.
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --initial-table                      [split, instrument] A hack to ensure the
-;; CHECK-NEXT:                                        split and instrumented modules have the
-;; CHECK-NEXT:                                        same table size when using Emscripten's
-;; CHECK-NEXT:                                        SPLIT_MODULE mode with dynamic linking.
-;; CHECK-NEXT:                                        TODO: Figure out a more elegant solution
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --initial-table                      [split, instrument] A hack to ensure the 
+;; CHECK-NEXT:                                        split and instrumented modules have the 
+;; CHECK-NEXT:                                        same table size when using Emscripten's 
+;; CHECK-NEXT:                                        SPLIT_MODULE mode with dynamic linking. 
+;; CHECK-NEXT:                                        TODO: Figure out a more elegant solution 
 ;; CHECK-NEXT:                                        for that use case and remove this.
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --emit-text,-S                       [split, multi-split, instrument] Emit
-;; CHECK-NEXT:                                        text instead of binary for the output
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --emit-text,-S                       [split, multi-split, instrument] Emit 
+;; CHECK-NEXT:                                        text instead of binary for the output 
 ;; CHECK-NEXT:                                        file or files.
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --debuginfo,-g                       [split, multi-split, instrument] Emit
-;; CHECK-NEXT:                                        names section in wasm binary (or full
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --debuginfo,-g                       [split, multi-split, instrument] Emit 
+;; CHECK-NEXT:                                        names section in wasm binary (or full 
 ;; CHECK-NEXT:                                        debuginfo in wast)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --strip-debug                        [split, multi-split, instrument] Strip
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --strip-debug                        [split, multi-split, instrument] Strip 
 ;; CHECK-NEXT:                                        debug info (including the names section)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --traps-never-happen,-tnh            [split, multi-split] Split under the
-;; CHECK-NEXT:                                        helpful assumption that no trap is
-;; CHECK-NEXT:                                        reached at runtime (from load, div/mod,
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --traps-never-happen,-tnh            [split, multi-split] Split under the 
+;; CHECK-NEXT:                                        helpful assumption that no trap is 
+;; CHECK-NEXT:                                        reached at runtime (from load, div/mod, 
 ;; CHECK-NEXT:                                        etc.)
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --output,-o                          [instrument, merge-profiles, multi-split]
 ;; CHECK-NEXT:                                        Output file.
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --verbose,-v                         Verbose output mode. Prints the functions
-;; CHECK-NEXT:                                        that will be kept and split out when
+;; CHECK-NEXT:                                        that will be kept and split out when 
 ;; CHECK-NEXT:                                        splitting a module.
-;; CHECK-NEXT:
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT: Tool options:
 ;; CHECK-NEXT: -------------
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --mvp-features,-mvp                  Disable all non-MVP features
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --all-features,-all                  Enable all features
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --detect-features                    (deprecated - this flag does nothing)
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --quiet,-q                           Emit less verbose output and hide trivial
 ;; CHECK-NEXT:                                        warnings.
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --experimental-poppy                 Parse wast files as Poppy IR for testing
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --experimental-poppy                 Parse wast files as Poppy IR for testing 
 ;; CHECK-NEXT:                                        purposes.
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --emit-module-names                  Emit module names, even if not emitting
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --emit-module-names                  Emit module names, even if not emitting 
 ;; CHECK-NEXT:                                        the rest of the names section.
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-sign-ext                    Enable sign extension operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-sign-ext                   Disable sign extension operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-threads                     Enable atomic operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-threads                    Disable atomic operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-mutable-globals             Enable mutable globals
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-mutable-globals            Disable mutable globals
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --enable-nontrapping-float-to-int    Enable nontrapping float-to-int
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --enable-nontrapping-float-to-int    Enable nontrapping float-to-int 
 ;; CHECK-NEXT:                                        operations
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --disable-nontrapping-float-to-int   Disable nontrapping float-to-int
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --disable-nontrapping-float-to-int   Disable nontrapping float-to-int 
 ;; CHECK-NEXT:                                        operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-simd                        Enable SIMD operations and types
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-simd                       Disable SIMD operations and types
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-bulk-memory                 Enable bulk memory operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-bulk-memory                Disable bulk memory operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-bulk-memory-opt             Enable memory.copy and memory.fill
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-bulk-memory-opt            Disable memory.copy and memory.fill
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --enable-call-indirect-overlong      Enable LEB encoding of call-indirect
-;; CHECK-NEXT:                                        (Ignored for compatibility as it has no
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --enable-call-indirect-overlong      Enable LEB encoding of call-indirect 
+;; CHECK-NEXT:                                        (Ignored for compatibility as it has no 
 ;; CHECK-NEXT:                                        effect on Binaryen)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --disable-call-indirect-overlong     Disable LEB encoding of call-indirect
-;; CHECK-NEXT:                                        (Ignored for compatibility as it has no
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --disable-call-indirect-overlong     Disable LEB encoding of call-indirect 
+;; CHECK-NEXT:                                        (Ignored for compatibility as it has no 
 ;; CHECK-NEXT:                                        effect on Binaryen)
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-exception-handling          Enable exception handling operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-exception-handling         Disable exception handling operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-tail-call                   Enable tail call operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-tail-call                  Disable tail call operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-reference-types             Enable reference types
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-reference-types            Disable reference types
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-multivalue                  Enable multivalue functions
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-multivalue                 Disable multivalue functions
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-gc                          Enable garbage collection
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-gc                         Disable garbage collection
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-memory64                    Enable memory64
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-memory64                   Disable memory64
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-relaxed-simd                Enable relaxed SIMD
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-relaxed-simd               Disable relaxed SIMD
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-extended-const              Enable extended const expressions
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-extended-const             Disable extended const expressions
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-strings                     Enable strings
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-strings                    Disable strings
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-multimemory                 Enable multimemory
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-multimemory                Disable multimemory
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-stack-switching             Enable stack switching
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-stack-switching            Disable stack switching
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-shared-everything           Enable shared-everything threads
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-shared-everything          Disable shared-everything threads
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-fp16                        Enable float 16 operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-fp16                       Disable float 16 operations
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --enable-custom-descriptors          Enable custom descriptors (RTTs) and
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --enable-custom-descriptors          Enable custom descriptors (RTTs) and 
 ;; CHECK-NEXT:                                        exact references
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --disable-custom-descriptors         Disable custom descriptors (RTTs) and
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --disable-custom-descriptors         Disable custom descriptors (RTTs) and 
 ;; CHECK-NEXT:                                        exact references
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-multibyte                   Enable multibyte array loads and stores
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-multibyte                  Disable multibyte array loads and stores
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --enable-acquire-release-atomics     Enable acquire/release atomic memory
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --enable-acquire-release-atomics     Enable acquire/release atomic memory 
 ;; CHECK-NEXT:                                        operations
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --disable-acquire-release-atomics    Disable acquire/release atomic memory
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --disable-acquire-release-atomics    Disable acquire/release atomic memory 
 ;; CHECK-NEXT:                                        operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-custom-page-sizes           Enable custom page sizes
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-custom-page-sizes          Disable custom page sizes
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-wide-arithmetic             Enable wide arithmetic
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-wide-arithmetic            Disable wide arithmetic
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-compact-imports             Enable compact import section
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-compact-imports            Disable compact import section
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-relaxed-atomics             Enable relaxed atomic memory operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-relaxed-atomics            Disable relaxed atomic memory operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-typed-function-references   Deprecated compatibility flag
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-typed-function-references  Deprecated compatibility flag
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --no-validation,-n                   Disables validation, assumes inputs are
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --no-validation,-n                   Disables validation, assumes inputs are 
 ;; CHECK-NEXT:                                        correct
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --pass-arg,-pa                       An argument passed along to optimization
-;; CHECK-NEXT:                                        passes being run. Must be in the form
-;; CHECK-NEXT:                                        KEY@VALUE.  If KEY is the name of a pass
-;; CHECK-NEXT:                                        then it applies to the closest instance
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --pass-arg,-pa                       An argument passed along to optimization 
+;; CHECK-NEXT:                                        passes being run. Must be in the form 
+;; CHECK-NEXT:                                        KEY@VALUE.  If KEY is the name of a pass 
+;; CHECK-NEXT:                                        then it applies to the closest instance 
 ;; CHECK-NEXT:                                        of that pass before us. If KEY is not the
 ;; CHECK-NEXT:                                        name of a pass then it is a global option
-;; CHECK-NEXT:                                        that applies to all pass instances that
+;; CHECK-NEXT:                                        that applies to all pass instances that 
 ;; CHECK-NEXT:                                        read it.
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --closed-world,-cw                   Assume code outside of the module does
-;; CHECK-NEXT:                                        not inspect or interact with GC and
-;; CHECK-NEXT:                                        function references, even if they are
-;; CHECK-NEXT:                                        passed out. The outside may hold on to
-;; CHECK-NEXT:                                        them and pass them back in, but not
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --closed-world,-cw                   Assume code outside of the module does 
+;; CHECK-NEXT:                                        not inspect or interact with GC and 
+;; CHECK-NEXT:                                        function references, even if they are 
+;; CHECK-NEXT:                                        passed out. The outside may hold on to 
+;; CHECK-NEXT:                                        them and pass them back in, but not 
 ;; CHECK-NEXT:                                        inspect their contents or call them.
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --preserve-type-order                Preserve the order of types from the
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --preserve-type-order                Preserve the order of types from the 
 ;; CHECK-NEXT:                                        input (useful for debugging and testing)
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --generate-stack-ir                  generate StackIR during writing
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --optimize-stack-ir                  optimize StackIR during writing
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --print-stack-ir                     print StackIR during writing
-;; CHECK-NEXT:
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT: General options:
 ;; CHECK-NEXT: ----------------
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --version                            Output version information and exit
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --help,-h                            Show this help message and exit
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --debug,-d                           Print debug information to stderr
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
diff --git a/test/lit/help/wasm2js.test b/test/lit/help/wasm2js.test
index d36cdb09410..d1f4db8f9e3 100644
--- a/test/lit/help/wasm2js.test
+++ b/test/lit/help/wasm2js.test
@@ -1,863 +1,863 @@
 ;; RUN: wasm2js --help | filecheck %s
 ;; CHECK: ================================================================================
 ;; CHECK-NEXT: wasm2js INFILE
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT: Transform .wasm/.wat files to asm.js
 ;; CHECK-NEXT: ================================================================================
-;; CHECK-NEXT:
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT: wasm2js options:
 ;; CHECK-NEXT: ----------------
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --output,-o                                   Output file (stdout if not
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --output,-o                                   Output file (stdout if not 
 ;; CHECK-NEXT:                                                 specified)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --allow-asserts                               Allow compilation of .wast
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --allow-asserts                               Allow compilation of .wast 
 ;; CHECK-NEXT:                                                 testing asserts
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --pedantic                                    Emulate WebAssembly trapping
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --pedantic                                    Emulate WebAssembly trapping 
 ;; CHECK-NEXT:                                                 behavior
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --emscripten                                  Emulate the glue in
-;; CHECK-NEXT:                                                 emscripten-compatible form (and
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --emscripten                                  Emulate the glue in 
+;; CHECK-NEXT:                                                 emscripten-compatible form (and 
 ;; CHECK-NEXT:                                                 not ES6 module form)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --deterministic                               Replace WebAssembly trapping
-;; CHECK-NEXT:                                                 behavior deterministically (the
-;; CHECK-NEXT:                                                 default is to not care about
-;; CHECK-NEXT:                                                 what would trap in wasm, like a
-;; CHECK-NEXT:                                                 load out of bounds or integer
-;; CHECK-NEXT:                                                 divide by zero; with this flag,
-;; CHECK-NEXT:                                                 we try to be deterministic at
-;; CHECK-NEXT:                                                 least in what happens, which
-;; CHECK-NEXT:                                                 might or might not be to trap
-;; CHECK-NEXT:                                                 like wasm, but at least should
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --deterministic                               Replace WebAssembly trapping 
+;; CHECK-NEXT:                                                 behavior deterministically (the 
+;; CHECK-NEXT:                                                 default is to not care about 
+;; CHECK-NEXT:                                                 what would trap in wasm, like a 
+;; CHECK-NEXT:                                                 load out of bounds or integer 
+;; CHECK-NEXT:                                                 divide by zero; with this flag, 
+;; CHECK-NEXT:                                                 we try to be deterministic at 
+;; CHECK-NEXT:                                                 least in what happens, which 
+;; CHECK-NEXT:                                                 might or might not be to trap 
+;; CHECK-NEXT:                                                 like wasm, but at least should 
 ;; CHECK-NEXT:                                                 not vary)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --symbols-file                                Emit a symbols file that maps
-;; CHECK-NEXT:                                                 function indexes to their
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --symbols-file                                Emit a symbols file that maps 
+;; CHECK-NEXT:                                                 function indexes to their 
 ;; CHECK-NEXT:                                                 original names
-;; CHECK-NEXT:
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT: Optimization passes:
 ;; CHECK-NEXT: --------------------
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --abstract-type-refining                      refine and merge abstract
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --abstract-type-refining                      refine and merge abstract 
 ;; CHECK-NEXT:                                                 (never-created) types
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --alignment-lowering                          lower unaligned loads and stores
 ;; CHECK-NEXT:                                                 to smaller aligned ones
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --asyncify                                    async/await style transform,
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --asyncify                                    async/await style transform, 
 ;; CHECK-NEXT:                                                 allowing pausing and resuming
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --avoid-reinterprets                          Tries to avoid reinterpret
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --avoid-reinterprets                          Tries to avoid reinterpret 
 ;; CHECK-NEXT:                                                 operations via more loads
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --cfp                                         propagate constant struct field
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --cfp                                         propagate constant struct field 
 ;; CHECK-NEXT:                                                 values
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --cfp-reftest                                 propagate constant struct field
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --cfp-reftest                                 propagate constant struct field 
 ;; CHECK-NEXT:                                                 values, using ref.test
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --coalesce-locals                             reduce # of locals by coalescing
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --coalesce-locals-learning                    reduce # of locals by coalescing
 ;; CHECK-NEXT:                                                 and learning
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --code-folding                                fold code, merging duplicates
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --code-pushing                                push code forward, potentially
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --code-pushing                                push code forward, potentially 
 ;; CHECK-NEXT:                                                 making it not always execute
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --const-hoisting                              hoist repeated constants to a
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --const-hoisting                              hoist repeated constants to a 
 ;; CHECK-NEXT:                                                 local
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --constraint-analysis                         finds and uses mathematical
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --constraint-analysis                         finds and uses mathematical 
 ;; CHECK-NEXT:                                                 constraints on locals
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --dae                                         removes arguments to calls in an
 ;; CHECK-NEXT:                                                 lto-like manner
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --dae-optimizing                              removes arguments to calls in an
-;; CHECK-NEXT:                                                 lto-like manner, and optimizes
+;; CHECK-NEXT:                                                 lto-like manner, and optimizes 
 ;; CHECK-NEXT:                                                 where we removed
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --dae2                                        Experimental reimplementation of
 ;; CHECK-NEXT:                                                 DAE
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --dce                                         removes unreachable code
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --dealign                                     forces all loads and stores to
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --dealign                                     forces all loads and stores to 
 ;; CHECK-NEXT:                                                 have alignment 1
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --denan                                       instrument the wasm to convert
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --denan                                       instrument the wasm to convert 
 ;; CHECK-NEXT:                                                 NaNs into 0 at runtime
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --dfo                                         optimizes using the DataFlow SSA
 ;; CHECK-NEXT:                                                 IR
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --directize                                   turns indirect calls into direct
 ;; CHECK-NEXT:                                                 ones
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --discard-global-effects                      discards global effect info
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --duplicate-function-elimination              removes duplicate functions
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --duplicate-import-elimination                removes duplicate imports
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --dwarfdump                                   dump DWARF debug info sections
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --dwarfdump                                   dump DWARF debug info sections 
 ;; CHECK-NEXT:                                                 from the read binary
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --emit-target-features                        emit the target features section
 ;; CHECK-NEXT:                                                 in the output
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --enclose-world                               modify the wasm (destructively)
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --enclose-world                               modify the wasm (destructively) 
 ;; CHECK-NEXT:                                                 for closed-world
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --extract-function                            leaves just one function (useful
 ;; CHECK-NEXT:                                                 for debugging)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --extract-function-index                      leaves just one function
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --extract-function-index                      leaves just one function 
 ;; CHECK-NEXT:                                                 selected by index
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --flatten                                     flattens out code, removing
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --flatten                                     flattens out code, removing 
 ;; CHECK-NEXT:                                                 nesting
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --fpcast-emu                                  emulates function pointer casts,
-;; CHECK-NEXT:                                                 allowing incorrect indirect
+;; CHECK-NEXT:                                                 allowing incorrect indirect 
 ;; CHECK-NEXT:                                                 calls to (sometimes) work
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --func-metrics                                reports function metrics
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --generate-dyncalls                           generate dynCall functions used
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --generate-dyncalls                           generate dynCall functions used 
 ;; CHECK-NEXT:                                                 by emscripten ABI
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --generate-global-effects                     generate global effect info
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --generate-global-effects                     generate global effect info 
 ;; CHECK-NEXT:                                                 (helps later passes)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --generate-i64-dyncalls                       generate dynCall functions used
-;; CHECK-NEXT:                                                 by emscripten ABI, but only for
-;; CHECK-NEXT:                                                 functions with i64 in their
-;; CHECK-NEXT:                                                 signature (which cannot be
-;; CHECK-NEXT:                                                 invoked via the wasm table
-;; CHECK-NEXT:                                                 without JavaScript BigInt
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --generate-i64-dyncalls                       generate dynCall functions used 
+;; CHECK-NEXT:                                                 by emscripten ABI, but only for 
+;; CHECK-NEXT:                                                 functions with i64 in their 
+;; CHECK-NEXT:                                                 signature (which cannot be 
+;; CHECK-NEXT:                                                 invoked via the wasm table 
+;; CHECK-NEXT:                                                 without JavaScript BigInt 
 ;; CHECK-NEXT:                                                 support).
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --global-refining                             refine the types of globals
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --gsi                                         globally optimize struct values
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --gsi-desc-cast                               globally optimize struct values,
 ;; CHECK-NEXT:                                                 also emitting ref.cast_desc_eq
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --gto                                         globally optimize GC types
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --gufa                                        Grand Unified Flow Analysis:
-;; CHECK-NEXT:                                                 optimize the entire program
-;; CHECK-NEXT:                                                 using information about what
-;; CHECK-NEXT:                                                 content can actually appear in
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --gufa                                        Grand Unified Flow Analysis: 
+;; CHECK-NEXT:                                                 optimize the entire program 
+;; CHECK-NEXT:                                                 using information about what 
+;; CHECK-NEXT:                                                 content can actually appear in 
 ;; CHECK-NEXT:                                                 each location
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --gufa-cast-all                               GUFA plus add casts for all
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --gufa-cast-all                               GUFA plus add casts for all 
 ;; CHECK-NEXT:                                                 inferences
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --gufa-optimizing                             GUFA plus local optimizations in
 ;; CHECK-NEXT:                                                 functions we modified
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --heap-store-optimization                     optimize heap (GC) stores
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --heap2local                                  replace GC allocations with
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --heap2local                                  replace GC allocations with 
 ;; CHECK-NEXT:                                                 locals
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --i64-to-i32-lowering                         lower all uses of i64s to use
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --i64-to-i32-lowering                         lower all uses of i64s to use 
 ;; CHECK-NEXT:                                                 i32s instead
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --inline-main                                 inline __original_main into main
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --inlining                                    inline functions (you probably
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --inlining                                    inline functions (you probably 
 ;; CHECK-NEXT:                                                 want inlining-optimizing)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --inlining-optimizing                         inline functions and optimizes
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --inlining-optimizing                         inline functions and optimizes 
 ;; CHECK-NEXT:                                                 where we inlined
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --instrument-branch-hints                     instrument branch hints so we
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --instrument-branch-hints                     instrument branch hints so we 
 ;; CHECK-NEXT:                                                 can see which guessed right
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --instrument-locals                           instrument the build with code
-;; CHECK-NEXT:                                                 to intercept all loads and
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --instrument-locals                           instrument the build with code 
+;; CHECK-NEXT:                                                 to intercept all loads and 
 ;; CHECK-NEXT:                                                 stores
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --instrument-memory                           instrument the build with code
-;; CHECK-NEXT:                                                 to intercept all loads and
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --instrument-memory                           instrument the build with code 
+;; CHECK-NEXT:                                                 to intercept all loads and 
 ;; CHECK-NEXT:                                                 stores
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --intrinsic-lowering                          lower away binaryen intrinsics
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --legalize-and-prune-js-interface             legalizes the import/export
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --legalize-and-prune-js-interface             legalizes the import/export 
 ;; CHECK-NEXT:                                                 boundary and prunes when needed
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --legalize-js-interface                       legalizes i64 types on the
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --legalize-js-interface                       legalizes i64 types on the 
 ;; CHECK-NEXT:                                                 import/export boundary
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --licm                                        loop invariant code motion
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --limit-segments                              attempt to merge segments to fit
 ;; CHECK-NEXT:                                                 within web limits
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --llvm-memory-copy-fill-lowering              Lower memory.copy and
-;; CHECK-NEXT:                                                 memory.fill to wasm mvp and
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --llvm-memory-copy-fill-lowering              Lower memory.copy and 
+;; CHECK-NEXT:                                                 memory.fill to wasm mvp and 
 ;; CHECK-NEXT:                                                 disable the bulk-memory feature.
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --llvm-nontrapping-fptoint-lowering           lower nontrapping float-to-int
-;; CHECK-NEXT:                                                 operations to wasm mvp and
-;; CHECK-NEXT:                                                 disable the nontrapping fptoint
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --llvm-nontrapping-fptoint-lowering           lower nontrapping float-to-int 
+;; CHECK-NEXT:                                                 operations to wasm mvp and 
+;; CHECK-NEXT:                                                 disable the nontrapping fptoint 
 ;; CHECK-NEXT:                                                 feature
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --local-cse                                   common subexpression elimination
 ;; CHECK-NEXT:                                                 inside basic blocks
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --local-subtyping                             apply more specific subtypes to
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --local-subtyping                             apply more specific subtypes to 
 ;; CHECK-NEXT:                                                 locals where possible
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --log-execution                               instrument the build with
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --log-execution                               instrument the build with 
 ;; CHECK-NEXT:                                                 logging of where execution goes
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --make-shared-objects                         Make structs and arrays shared
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --make-shared-objects                         Make structs and arrays shared 
 ;; CHECK-NEXT:                                                 and functions unshared
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --mark-js-called                              mark js called functions (using
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --mark-js-called                              mark js called functions (using 
 ;; CHECK-NEXT:                                                 configureAll) as doing so
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --memory-packing                              packs memory into separate
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --memory-packing                              packs memory into separate 
 ;; CHECK-NEXT:                                                 segments, skipping zeros
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --memory64-lowering                           lower loads and stores to a
-;; CHECK-NEXT:                                                 64-bit memory to instead use a
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --memory64-lowering                           lower loads and stores to a 
+;; CHECK-NEXT:                                                 64-bit memory to instead use a 
 ;; CHECK-NEXT:                                                 32-bit one
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --merge-blocks                                merges blocks to their parents
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --merge-j2cl-itables                          Merges itable structures into
-;; CHECK-NEXT:                                                 vtables to make types more
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --merge-j2cl-itables                          Merges itable structures into 
+;; CHECK-NEXT:                                                 vtables to make types more 
 ;; CHECK-NEXT:                                                 compact
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --merge-locals                                merges locals when beneficial
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --merge-similar-functions                     merges similar functions when
-;; CHECK-NEXT:                                                 benefical
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --metrics                                     reports metrics (with an
-;; CHECK-NEXT:                                                 optional title,
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --merge-similar-functions                     merges similar functions when 
+;; CHECK-NEXT:                                                 beneficial
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --metrics                                     reports metrics (with an 
+;; CHECK-NEXT:                                                 optional title, 
 ;; CHECK-NEXT:                                                 --metrics[=TITLE])
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --minify-imports                              minifies import names (only
-;; CHECK-NEXT:                                                 those, and not export names),
-;; CHECK-NEXT:                                                 and emits a mapping to the
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --minify-imports                              minifies import names (only 
+;; CHECK-NEXT:                                                 those, and not export names), 
+;; CHECK-NEXT:                                                 and emits a mapping to the 
 ;; CHECK-NEXT:                                                 minified ones
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --minify-imports-and-exports                  minifies both import and export
-;; CHECK-NEXT:                                                 names, and emits a mapping to
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --minify-imports-and-exports                  minifies both import and export 
+;; CHECK-NEXT:                                                 names, and emits a mapping to 
 ;; CHECK-NEXT:                                                 the minified ones
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --minify-imports-and-exports-and-modules      minifies both import and export
-;; CHECK-NEXT:                                                 names, and emits a mapping to
-;; CHECK-NEXT:                                                 the minified ones, and minifies
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --minify-imports-and-exports-and-modules      minifies both import and export 
+;; CHECK-NEXT:                                                 names, and emits a mapping to 
+;; CHECK-NEXT:                                                 the minified ones, and minifies 
 ;; CHECK-NEXT:                                                 the modules as well
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --minimize-rec-groups                         Split types into minimal
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --minimize-rec-groups                         Split types into minimal 
 ;; CHECK-NEXT:                                                 recursion groups
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --monomorphize                                creates specialized versions of
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --monomorphize                                creates specialized versions of 
 ;; CHECK-NEXT:                                                 functions
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --monomorphize-always                         creates specialized versions of
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --monomorphize-always                         creates specialized versions of 
 ;; CHECK-NEXT:                                                 functions (even if unhelpful)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --multi-memory-lowering                       combines multiple memories into
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --multi-memory-lowering                       combines multiple memories into 
 ;; CHECK-NEXT:                                                 a single memory
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --multi-memory-lowering-with-bounds-checks    combines multiple memories into
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --multi-memory-lowering-with-bounds-checks    combines multiple memories into 
 ;; CHECK-NEXT:                                                 a single memory, trapping if the
 ;; CHECK-NEXT:                                                 read or write is larger than the
 ;; CHECK-NEXT:                                                 length of the memory's data
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --name-types                                  (re)name all heap types
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --nm                                          name list
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --no-full-inline                              mark functions as no-inline (for
 ;; CHECK-NEXT:                                                 full inlining only)
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --no-inline                                   mark functions as no-inline
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --no-partial-inline                           mark functions as no-inline (for
 ;; CHECK-NEXT:                                                 partial inlining only)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --once-reduction                              reduces calls to code that only
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --once-reduction                              reduces calls to code that only 
 ;; CHECK-NEXT:                                                 runs once
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --optimize-added-constants                    optimizes added constants into
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --optimize-added-constants                    optimizes added constants into 
 ;; CHECK-NEXT:                                                 load/store offsets
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --optimize-added-constants-propagate          optimizes added constants into
-;; CHECK-NEXT:                                                 load/store offsets, propagating
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --optimize-added-constants-propagate          optimizes added constants into 
+;; CHECK-NEXT:                                                 load/store offsets, propagating 
 ;; CHECK-NEXT:                                                 them across locals too
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --optimize-casts                              eliminate and reuse casts
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --optimize-for-js                             early optimize of the
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --optimize-for-js                             early optimize of the 
 ;; CHECK-NEXT:                                                 instruction combinations for js
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --optimize-instructions                       optimizes instruction
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --optimize-instructions                       optimizes instruction 
 ;; CHECK-NEXT:                                                 combinations
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --optimize-j2cl                               optimizes J2CL specific
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --optimize-j2cl                               optimizes J2CL specific 
 ;; CHECK-NEXT:                                                 constructs.
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --outlining                                   outline instructions
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --pick-load-signs                             pick load signs based on their
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --pick-load-signs                             pick load signs based on their 
 ;; CHECK-NEXT:                                                 uses
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --poppify                                     Transform Binaryen IR into Poppy
 ;; CHECK-NEXT:                                                 IR
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --post-emscripten                             miscellaneous optimizations for
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --post-emscripten                             miscellaneous optimizations for 
 ;; CHECK-NEXT:                                                 Emscripten-generated code
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --precompute                                  computes compile-time
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --precompute                                  computes compile-time 
 ;; CHECK-NEXT:                                                 evaluatable expressions
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --precompute-propagate                        computes compile-time
-;; CHECK-NEXT:                                                 evaluatable expressions and
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --precompute-propagate                        computes compile-time 
+;; CHECK-NEXT:                                                 evaluatable expressions and 
 ;; CHECK-NEXT:                                                 propagates them through locals
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --print                                       print in s-expression format
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --print-boundary                              print boundary in JSON format
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --print-call-graph                            print call graph
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --print-features                              print options for enabled
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --print-features                              print options for enabled 
 ;; CHECK-NEXT:                                                 features
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --print-full                                  print in full s-expression
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --print-full                                  print in full s-expression 
 ;; CHECK-NEXT:                                                 format
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --print-function-map                          print a map of function indexes
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --print-function-map                          print a map of function indexes 
 ;; CHECK-NEXT:                                                 to names
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --print-minified                              print in minified s-expression
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --print-minified                              print in minified s-expression 
 ;; CHECK-NEXT:                                                 format
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --propagate-debug-locs                        propagate debug location from
-;; CHECK-NEXT:                                                 parents or previous siblings to
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --propagate-debug-locs                        propagate debug location from 
+;; CHECK-NEXT:                                                 parents or previous siblings to 
 ;; CHECK-NEXT:                                                 child nodes
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --propagate-globals-globally                  propagate global values to other
 ;; CHECK-NEXT:                                                 globals (useful for tests)
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --remove-empty-function-exports               removes exports of empty
+;; CHECK-NEXT:                                                 functions
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --remove-exports                              removes exports using a wildcard
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --remove-imports                              removes imports and replaces
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --remove-imports                              removes imports and replaces 
 ;; CHECK-NEXT:                                                 them with nops
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --remove-memory                               removes memory init (legacy
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --remove-memory                               removes memory init (legacy 
 ;; CHECK-NEXT:                                                 name)
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --remove-memory-init                          removes memory initialization
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --remove-non-js-ops                           removes operations incompatible
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --remove-non-js-ops                           removes operations incompatible 
 ;; CHECK-NEXT:                                                 with js
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --remove-relaxed-simd                         replaces relaxed SIMD
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --remove-relaxed-simd                         replaces relaxed SIMD 
 ;; CHECK-NEXT:                                                 instructions with unreachable
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --remove-unused-brs                           removes breaks from locations
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --remove-unused-brs                           removes breaks from locations 
 ;; CHECK-NEXT:                                                 that are not needed
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --remove-unused-module-elements               removes unused module elements
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --remove-unused-names                         removes names from locations
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --remove-unused-names                         removes names from locations 
 ;; CHECK-NEXT:                                                 that are never branched to
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --remove-unused-nonfunction-module-elements   removes unused module elements
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --remove-unused-nonfunction-module-elements   removes unused module elements 
 ;; CHECK-NEXT:                                                 that are not functions
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --remove-unused-types                         remove unused private GC types
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --reorder-functions                           sorts functions by access
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --reorder-functions                           sorts functions by access 
 ;; CHECK-NEXT:                                                 frequency
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --reorder-functions-by-name                   sorts functions by name (useful
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --reorder-functions-by-name                   sorts functions by name (useful 
 ;; CHECK-NEXT:                                                 for debugging)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --reorder-globals                             sorts globals by access
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --reorder-globals                             sorts globals by access 
 ;; CHECK-NEXT:                                                 frequency
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --reorder-locals                              sorts locals by access frequency
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --reorder-types                               sorts private types by access
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --reorder-types                               sorts private types by access 
 ;; CHECK-NEXT:                                                 frequency
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --rereloop                                    re-optimize control flow using
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --rereloop                                    re-optimize control flow using 
 ;; CHECK-NEXT:                                                 the relooper algorithm
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --roundtrip                                   write the module to binary, then
 ;; CHECK-NEXT:                                                 read it
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --rse                                         remove redundant local.sets
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --safe-heap                                   instrument loads and stores to
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --safe-heap                                   instrument loads and stores to 
 ;; CHECK-NEXT:                                                 check for invalid behavior
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --separate-data-segments                      write data segments to a file
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --separate-data-segments                      write data segments to a file 
 ;; CHECK-NEXT:                                                 and strip them from the module
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --set-globals                                 sets specified globals to
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --set-globals                                 sets specified globals to 
 ;; CHECK-NEXT:                                                 specified values
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --signature-pruning                           remove params from function
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --signature-pruning                           remove params from function 
 ;; CHECK-NEXT:                                                 signature types where possible
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --signature-refining                          apply more specific subtypes to
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --signature-refining                          apply more specific subtypes to 
 ;; CHECK-NEXT:                                                 signature types where possible
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --signext-lowering                            lower sign-ext operations to
-;; CHECK-NEXT:                                                 wasm mvp and disable the sign
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --signext-lowering                            lower sign-ext operations to 
+;; CHECK-NEXT:                                                 wasm mvp and disable the sign 
 ;; CHECK-NEXT:                                                 extension feature
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --simplify-globals                            miscellaneous globals-related
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --simplify-globals                            miscellaneous globals-related 
 ;; CHECK-NEXT:                                                 optimizations
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --simplify-globals-optimizing                 miscellaneous globals-related
-;; CHECK-NEXT:                                                 optimizations, and optimizes
-;; CHECK-NEXT:                                                 where we replaced global.gets
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --simplify-globals-optimizing                 miscellaneous globals-related 
+;; CHECK-NEXT:                                                 optimizations, and optimizes 
+;; CHECK-NEXT:                                                 where we replaced global.gets 
 ;; CHECK-NEXT:                                                 with constants
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --simplify-locals                             miscellaneous locals-related
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --simplify-locals                             miscellaneous locals-related 
 ;; CHECK-NEXT:                                                 optimizations
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --simplify-locals-nonesting                   miscellaneous locals-related
-;; CHECK-NEXT:                                                 optimizations (no nesting at
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --simplify-locals-nonesting                   miscellaneous locals-related 
+;; CHECK-NEXT:                                                 optimizations (no nesting at 
 ;; CHECK-NEXT:                                                 all; preserves flatness)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --simplify-locals-nostructure                 miscellaneous locals-related
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --simplify-locals-nostructure                 miscellaneous locals-related 
 ;; CHECK-NEXT:                                                 optimizations (no structure)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --simplify-locals-notee                       miscellaneous locals-related
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --simplify-locals-notee                       miscellaneous locals-related 
 ;; CHECK-NEXT:                                                 optimizations (no tees)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --simplify-locals-notee-nostructure           miscellaneous locals-related
-;; CHECK-NEXT:                                                 optimizations (no tees or
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --simplify-locals-notee-nostructure           miscellaneous locals-related 
+;; CHECK-NEXT:                                                 optimizations (no tees or 
 ;; CHECK-NEXT:                                                 structure)
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --souperify                                   emit Souper IR in text form
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --souperify-single-use                        emit Souper IR in text form
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --souperify-single-use                        emit Souper IR in text form 
 ;; CHECK-NEXT:                                                 (single-use nodes only)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --spill-pointers                              spill pointers to the C stack
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --spill-pointers                              spill pointers to the C stack 
 ;; CHECK-NEXT:                                                 (useful for Boehm-style GC)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --ssa                                         ssa-ify variables so that they
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --ssa                                         ssa-ify variables so that they 
 ;; CHECK-NEXT:                                                 have a single assignment
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --ssa-nomerge                                 ssa-ify variables so that they
-;; CHECK-NEXT:                                                 have a single assignment,
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --ssa-nomerge                                 ssa-ify variables so that they 
+;; CHECK-NEXT:                                                 have a single assignment, 
 ;; CHECK-NEXT:                                                 ignoring merges
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --stack-check                                 enforce limits on llvm's
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --stack-check                                 enforce limits on llvm's 
 ;; CHECK-NEXT:                                                 __stack_pointer global
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --string-gathering                            gathers wasm strings to globals
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --string-lifting                              lift string imports to wasm
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --string-lifting                              lift string imports to wasm 
 ;; CHECK-NEXT:                                                 strings
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --string-lowering                             lowers wasm strings and
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --string-lowering                             lowers wasm strings and 
 ;; CHECK-NEXT:                                                 operations to imports
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --string-lowering-magic-imports               same as string-lowering, but
-;; CHECK-NEXT:                                                 encodes well-formed strings as
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --string-lowering-magic-imports               same as string-lowering, but 
+;; CHECK-NEXT:                                                 encodes well-formed strings as 
 ;; CHECK-NEXT:                                                 magic imports
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --string-lowering-magic-imports-assert        same as
-;; CHECK-NEXT:                                                 string-lowering-magic-imports,
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --string-lowering-magic-imports-assert        same as 
+;; CHECK-NEXT:                                                 string-lowering-magic-imports, 
 ;; CHECK-NEXT:                                                 but raise a fatal error if there
 ;; CHECK-NEXT:                                                 are invalid strings
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --strip                                       deprecated; same as strip-debug
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --strip-debug                                 strip debug info (including the
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --strip-debug                                 strip debug info (including the 
 ;; CHECK-NEXT:                                                 names section)
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --strip-dwarf                                 strip dwarf debug info
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --strip-eh                                    strip EH instructions
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --strip-producers                             strip the wasm producers section
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --strip-target-features                       strip the wasm target features
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --strip-target-features                       strip the wasm target features 
 ;; CHECK-NEXT:                                                 section
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --strip-toolchain-annotations                 strip all toolchain-specific
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --strip-toolchain-annotations                 strip all toolchain-specific 
 ;; CHECK-NEXT:                                                 code annotations
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --stub-unsupported-js                         stub out unsupported JS
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --stub-unsupported-js                         stub out unsupported JS 
 ;; CHECK-NEXT:                                                 operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --symbolmap                                   (alias for print-function-map)
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --table64-lowering                            alias for memory64-lowering
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --trace-calls                                 instrument the build with code
-;; CHECK-NEXT:                                                 to intercept specific function
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --tail-call                                   convert calls in tail position 
+;; CHECK-NEXT:                                                 to return calls
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --trace-calls                                 instrument the build with code 
+;; CHECK-NEXT:                                                 to intercept specific function 
 ;; CHECK-NEXT:                                                 calls
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --translate-to-exnref                         translate old Phase 3 EH
-;; CHECK-NEXT:                                                 instructions to new ones with
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --translate-to-exnref                         translate old Phase 3 EH 
+;; CHECK-NEXT:                                                 instructions to new ones with 
 ;; CHECK-NEXT:                                                 exnref
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --translate-to-new-eh                         deprecated; same as
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --translate-to-new-eh                         deprecated; same as 
 ;; CHECK-NEXT:                                                 translate-to-exnref
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --trap-mode-clamp                             replace trapping operations with
-;; CHECK-NEXT:                                                 clamping semantics
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --trap-mode-js                                replace trapping operations with
-;; CHECK-NEXT:                                                 js semantics
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --tuple-optimization                          optimize trivial tuples away
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --type-finalizing                             mark all leaf types as final
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --type-merging                                merge types to their supertypes
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --type-merging                                merge types to their supertypes 
 ;; CHECK-NEXT:                                                 where possible
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --type-refining                               apply more specific subtypes to
-;; CHECK-NEXT:                                                 type fields where possible
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --type-refining-gufa                          apply more specific subtypes to
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --type-refining                               apply more specific subtypes to 
 ;; CHECK-NEXT:                                                 type fields where possible
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --type-refining-gufa                          apply more specific subtypes to 
+;; CHECK-NEXT:                                                 type fields where possible 
 ;; CHECK-NEXT:                                                 (using GUFA)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --type-ssa                                    create new types to help other
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --type-ssa                                    create new types to help other 
 ;; CHECK-NEXT:                                                 optimizations
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --type-unfinalizing                           mark all types as non-final
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --type-unfinalizing                           mark all types as non-final 
 ;; CHECK-NEXT:                                                 (open)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --unsubtyping                                 removes unnecessary subtyping
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --unsubtyping                                 removes unnecessary subtyping 
 ;; CHECK-NEXT:                                                 relationships
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --untee                                       removes local.tees, replacing
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --untee                                       removes local.tees, replacing 
 ;; CHECK-NEXT:                                                 them with sets and gets
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --vacuum                                      removes obviously unneeded code
-;; CHECK-NEXT:
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT: Optimization options:
 ;; CHECK-NEXT: ---------------------
-;; CHECK-NEXT:
-;; CHECK-NEXT:    -O                                           execute default optimization
+;; CHECK-EMPTY:
+;; CHECK-NEXT:    -O                                           execute default optimization 
 ;; CHECK-NEXT:                                                 passes (equivalent to -Os)
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:    -O0                                          execute no optimization passes
-;; CHECK-NEXT:
-;; CHECK-NEXT:    -O1                                          execute -O1 optimization passes
-;; CHECK-NEXT:                                                 (quick&useful opts, useful for
+;; CHECK-EMPTY:
+;; CHECK-NEXT:    -O1                                          execute -O1 optimization passes 
+;; CHECK-NEXT:                                                 (quick&useful opts, useful for 
 ;; CHECK-NEXT:                                                 iteration builds)
-;; CHECK-NEXT:
-;; CHECK-NEXT:    -O2                                          execute -O2 optimization passes
-;; CHECK-NEXT:                                                 (most opts, generally gets most
+;; CHECK-EMPTY:
+;; CHECK-NEXT:    -O2                                          execute -O2 optimization passes 
+;; CHECK-NEXT:                                                 (most opts, generally gets most 
 ;; CHECK-NEXT:                                                 perf)
-;; CHECK-NEXT:
-;; CHECK-NEXT:    -O3                                          execute -O3 optimization passes
-;; CHECK-NEXT:                                                 (spends potentially a lot of
+;; CHECK-EMPTY:
+;; CHECK-NEXT:    -O3                                          execute -O3 optimization passes 
+;; CHECK-NEXT:                                                 (spends potentially a lot of 
 ;; CHECK-NEXT:                                                 time optimizing)
-;; CHECK-NEXT:
-;; CHECK-NEXT:    -O4                                          execute -O4 optimization passes
-;; CHECK-NEXT:                                                 (also flatten the IR, which can
+;; CHECK-EMPTY:
+;; CHECK-NEXT:    -O4                                          execute -O4 optimization passes 
+;; CHECK-NEXT:                                                 (also flatten the IR, which can 
 ;; CHECK-NEXT:                                                 take a lot more time and memory,
-;; CHECK-NEXT:                                                 but is useful on more nested /
+;; CHECK-NEXT:                                                 but is useful on more nested / 
 ;; CHECK-NEXT:                                                 complex / less-optimized input)
-;; CHECK-NEXT:
-;; CHECK-NEXT:    -Os                                          execute default optimization
+;; CHECK-EMPTY:
+;; CHECK-NEXT:    -Os                                          execute default optimization 
 ;; CHECK-NEXT:                                                 passes, focusing on code size
-;; CHECK-NEXT:
-;; CHECK-NEXT:    -Oz                                          execute default optimization
-;; CHECK-NEXT:                                                 passes, super-focusing on code
+;; CHECK-EMPTY:
+;; CHECK-NEXT:    -Oz                                          execute default optimization 
+;; CHECK-NEXT:                                                 passes, super-focusing on code 
 ;; CHECK-NEXT:                                                 size
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --optimize-level,-ol                          How much to focus on optimizing
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --optimize-level,-ol                          How much to focus on optimizing 
 ;; CHECK-NEXT:                                                 code
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --shrink-level,-s                             How much to focus on shrinking
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --shrink-level,-s                             How much to focus on shrinking 
 ;; CHECK-NEXT:                                                 code size
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --debuginfo,-g                                Emit names section in wasm
-;; CHECK-NEXT:                                                 binary (or full debuginfo in
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --debuginfo,-g                                Emit names section in wasm 
+;; CHECK-NEXT:                                                 binary (or full debuginfo in 
 ;; CHECK-NEXT:                                                 wast)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --always-inline-max-function-size,-aimfs      Max size of functions that are
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --always-inline-max-function-size,-aimfs      Max size of functions that are 
 ;; CHECK-NEXT:                                                 always inlined (default 2, which
 ;; CHECK-NEXT:                                                 is safe for use with -Os builds)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --flexible-inline-max-function-size,-fimfs    Max size of functions that are
-;; CHECK-NEXT:                                                 inlined when lightweight (no
-;; CHECK-NEXT:                                                 loops or function calls) when
-;; CHECK-NEXT:                                                 optimizing aggressively for
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --flexible-inline-max-function-size,-fimfs    Max size of functions that are 
+;; CHECK-NEXT:                                                 inlined when lightweight (no 
+;; CHECK-NEXT:                                                 loops or function calls) when 
+;; CHECK-NEXT:                                                 optimizing aggressively for 
 ;; CHECK-NEXT:                                                 speed (-O3). Default: 20
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --one-caller-inline-max-function-size,-ocimfs Max size of functions that are
-;; CHECK-NEXT:                                                 inlined when there is only one
-;; CHECK-NEXT:                                                 caller (default -1, which means
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --one-caller-inline-max-function-size,-ocimfs Max size of functions that are 
+;; CHECK-NEXT:                                                 inlined when there is only one 
+;; CHECK-NEXT:                                                 caller (default -1, which means 
 ;; CHECK-NEXT:                                                 all such functions are inlined)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --inline-max-combined-binary-size,-imcbs      Max size of combined functions
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --inline-max-combined-binary-size,-imcbs      Max size of combined functions 
 ;; CHECK-NEXT:                                                 after inlining. Default: 409600
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --inline-functions-with-loops,-ifwl           Allow inlining functions with
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --inline-functions-with-loops,-ifwl           Allow inlining functions with 
 ;; CHECK-NEXT:                                                 loops
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --partial-inlining-ifs,-pii                   Number of ifs allowed in partial
-;; CHECK-NEXT:                                                 inlining (zero means partial
-;; CHECK-NEXT:                                                 inlining is disabled) (default:
+;; CHECK-NEXT:                                                 inlining (zero means partial 
+;; CHECK-NEXT:                                                 inlining is disabled) (default: 
 ;; CHECK-NEXT:                                                 0)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --ignore-implicit-traps,-iit                  Optimize under the helpful
-;; CHECK-NEXT:                                                 assumption that no surprising
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --ignore-implicit-traps,-iit                  Optimize under the helpful 
+;; CHECK-NEXT:                                                 assumption that no surprising 
 ;; CHECK-NEXT:                                                 traps occur (from load, div/mod,
 ;; CHECK-NEXT:                                                 etc.)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --traps-never-happen,-tnh                     Optimize under the helpful
-;; CHECK-NEXT:                                                 assumption that no trap is
-;; CHECK-NEXT:                                                 reached at runtime (from load,
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --traps-never-happen,-tnh                     Optimize under the helpful 
+;; CHECK-NEXT:                                                 assumption that no trap is 
+;; CHECK-NEXT:                                                 reached at runtime (from load, 
 ;; CHECK-NEXT:                                                 div/mod, etc.)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --low-memory-unused,-lmu                      Optimize under the helpful
-;; CHECK-NEXT:                                                 assumption that the low 1K of
-;; CHECK-NEXT:                                                 memory is not used by the
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --low-memory-unused,-lmu                      Optimize under the helpful 
+;; CHECK-NEXT:                                                 assumption that the low 1K of 
+;; CHECK-NEXT:                                                 memory is not used by the 
 ;; CHECK-NEXT:                                                 application
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --fast-math,-ffm                              Optimize floats without handling
-;; CHECK-NEXT:                                                 corner cases of NaNs and
-;; CHECK-NEXT:                                                 rounding
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --zero-filled-memory,-uim                     Assume that an imported memory
+;; CHECK-NEXT:                                                 corner cases of NaNs, rounding, 
+;; CHECK-NEXT:                                                 and negative zero
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --zero-filled-memory,-uim                     Assume that an imported memory 
 ;; CHECK-NEXT:                                                 will be zero-initialized
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --skip-pass,-sp                               Skip a pass (do not run it)
-;; CHECK-NEXT:
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT: Tool options:
 ;; CHECK-NEXT: -------------
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --mvp-features,-mvp                           Disable all non-MVP features
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --all-features,-all                           Enable all features
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --detect-features                             (deprecated - this flag does
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --detect-features                             (deprecated - this flag does 
 ;; CHECK-NEXT:                                                 nothing)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --quiet,-q                                    Emit less verbose output and
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --quiet,-q                                    Emit less verbose output and 
 ;; CHECK-NEXT:                                                 hide trivial warnings.
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --experimental-poppy                          Parse wast files as Poppy IR for
 ;; CHECK-NEXT:                                                 testing purposes.
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --emit-module-names                           Emit module names, even if not
-;; CHECK-NEXT:                                                 emitting the rest of the names
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --emit-module-names                           Emit module names, even if not 
+;; CHECK-NEXT:                                                 emitting the rest of the names 
 ;; CHECK-NEXT:                                                 section.
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-sign-ext                             Enable sign extension operations
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --disable-sign-ext                            Disable sign extension
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --disable-sign-ext                            Disable sign extension 
 ;; CHECK-NEXT:                                                 operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-threads                              Enable atomic operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-threads                             Disable atomic operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-mutable-globals                      Enable mutable globals
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-mutable-globals                     Disable mutable globals
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --enable-nontrapping-float-to-int             Enable nontrapping float-to-int
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --enable-nontrapping-float-to-int             Enable nontrapping float-to-int 
 ;; CHECK-NEXT:                                                 operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-nontrapping-float-to-int            Disable nontrapping float-to-int
 ;; CHECK-NEXT:                                                 operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-simd                                 Enable SIMD operations and types
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --disable-simd                                Disable SIMD operations and
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --disable-simd                                Disable SIMD operations and 
 ;; CHECK-NEXT:                                                 types
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-bulk-memory                          Enable bulk memory operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-bulk-memory                         Disable bulk memory operations
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --enable-bulk-memory-opt                      Enable memory.copy and
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --enable-bulk-memory-opt                      Enable memory.copy and 
 ;; CHECK-NEXT:                                                 memory.fill
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --disable-bulk-memory-opt                     Disable memory.copy and
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --disable-bulk-memory-opt                     Disable memory.copy and 
 ;; CHECK-NEXT:                                                 memory.fill
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --enable-call-indirect-overlong               Enable LEB encoding of
-;; CHECK-NEXT:                                                 call-indirect (Ignored for
-;; CHECK-NEXT:                                                 compatibility as it has no
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --enable-call-indirect-overlong               Enable LEB encoding of 
+;; CHECK-NEXT:                                                 call-indirect (Ignored for 
+;; CHECK-NEXT:                                                 compatibility as it has no 
 ;; CHECK-NEXT:                                                 effect on Binaryen)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --disable-call-indirect-overlong              Disable LEB encoding of
-;; CHECK-NEXT:                                                 call-indirect (Ignored for
-;; CHECK-NEXT:                                                 compatibility as it has no
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --disable-call-indirect-overlong              Disable LEB encoding of 
+;; CHECK-NEXT:                                                 call-indirect (Ignored for 
+;; CHECK-NEXT:                                                 compatibility as it has no 
 ;; CHECK-NEXT:                                                 effect on Binaryen)
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --enable-exception-handling                   Enable exception handling
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --enable-exception-handling                   Enable exception handling 
 ;; CHECK-NEXT:                                                 operations
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --disable-exception-handling                  Disable exception handling
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --disable-exception-handling                  Disable exception handling 
 ;; CHECK-NEXT:                                                 operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-tail-call                            Enable tail call operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-tail-call                           Disable tail call operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-reference-types                      Enable reference types
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-reference-types                     Disable reference types
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-multivalue                           Enable multivalue functions
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-multivalue                          Disable multivalue functions
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-gc                                   Enable garbage collection
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-gc                                  Disable garbage collection
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-memory64                             Enable memory64
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-memory64                            Disable memory64
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-relaxed-simd                         Enable relaxed SIMD
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-relaxed-simd                        Disable relaxed SIMD
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --enable-extended-const                       Enable extended const
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --enable-extended-const                       Enable extended const 
 ;; CHECK-NEXT:                                                 expressions
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --disable-extended-const                      Disable extended const
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --disable-extended-const                      Disable extended const 
 ;; CHECK-NEXT:                                                 expressions
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-strings                              Enable strings
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-strings                             Disable strings
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-multimemory                          Enable multimemory
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-multimemory                         Disable multimemory
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-stack-switching                      Enable stack switching
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-stack-switching                     Disable stack switching
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-shared-everything                    Enable shared-everything threads
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --disable-shared-everything                   Disable shared-everything
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --disable-shared-everything                   Disable shared-everything 
 ;; CHECK-NEXT:                                                 threads
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-fp16                                 Enable float 16 operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-fp16                                Disable float 16 operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-custom-descriptors                   Enable custom descriptors (RTTs)
 ;; CHECK-NEXT:                                                 and exact references
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --disable-custom-descriptors                  Disable custom descriptors
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --disable-custom-descriptors                  Disable custom descriptors 
 ;; CHECK-NEXT:                                                 (RTTs) and exact references
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-multibyte                            Enable multibyte array loads and
 ;; CHECK-NEXT:                                                 stores
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --disable-multibyte                           Disable multibyte array loads
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --disable-multibyte                           Disable multibyte array loads 
 ;; CHECK-NEXT:                                                 and stores
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --enable-acquire-release-atomics              Enable acquire/release atomic
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --enable-acquire-release-atomics              Enable acquire/release atomic 
 ;; CHECK-NEXT:                                                 memory operations
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --disable-acquire-release-atomics             Disable acquire/release atomic
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --disable-acquire-release-atomics             Disable acquire/release atomic 
 ;; CHECK-NEXT:                                                 memory operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-custom-page-sizes                    Enable custom page sizes
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-custom-page-sizes                   Disable custom page sizes
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-wide-arithmetic                      Enable wide arithmetic
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-wide-arithmetic                     Disable wide arithmetic
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-compact-imports                      Enable compact import section
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-compact-imports                     Disable compact import section
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --enable-relaxed-atomics                      Enable relaxed atomic memory
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --enable-relaxed-atomics                      Enable relaxed atomic memory 
 ;; CHECK-NEXT:                                                 operations
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --disable-relaxed-atomics                     Disable relaxed atomic memory
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --disable-relaxed-atomics                     Disable relaxed atomic memory 
 ;; CHECK-NEXT:                                                 operations
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --enable-typed-function-references            Deprecated compatibility flag
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --disable-typed-function-references           Deprecated compatibility flag
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --no-validation,-n                            Disables validation, assumes
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --no-validation,-n                            Disables validation, assumes 
 ;; CHECK-NEXT:                                                 inputs are correct
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --pass-arg,-pa                                An argument passed along to
-;; CHECK-NEXT:                                                 optimization passes being run.
-;; CHECK-NEXT:                                                 Must be in the form KEY@VALUE.
-;; CHECK-NEXT:                                                 If KEY is the name of a pass
-;; CHECK-NEXT:                                                 then it applies to the closest
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --pass-arg,-pa                                An argument passed along to 
+;; CHECK-NEXT:                                                 optimization passes being run. 
+;; CHECK-NEXT:                                                 Must be in the form KEY@VALUE.  
+;; CHECK-NEXT:                                                 If KEY is the name of a pass 
+;; CHECK-NEXT:                                                 then it applies to the closest 
 ;; CHECK-NEXT:                                                 instance of that pass before us.
 ;; CHECK-NEXT:                                                 If KEY is not the name of a pass
-;; CHECK-NEXT:                                                 then it is a global option that
-;; CHECK-NEXT:                                                 applies to all pass instances
+;; CHECK-NEXT:                                                 then it is a global option that 
+;; CHECK-NEXT:                                                 applies to all pass instances 
 ;; CHECK-NEXT:                                                 that read it.
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --closed-world,-cw                            Assume code outside of the
-;; CHECK-NEXT:                                                 module does not inspect or
-;; CHECK-NEXT:                                                 interact with GC and function
-;; CHECK-NEXT:                                                 references, even if they are
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --closed-world,-cw                            Assume code outside of the 
+;; CHECK-NEXT:                                                 module does not inspect or 
+;; CHECK-NEXT:                                                 interact with GC and function 
+;; CHECK-NEXT:                                                 references, even if they are 
 ;; CHECK-NEXT:                                                 passed out. The outside may hold
-;; CHECK-NEXT:                                                 on to them and pass them back
-;; CHECK-NEXT:                                                 in, but not inspect their
+;; CHECK-NEXT:                                                 on to them and pass them back 
+;; CHECK-NEXT:                                                 in, but not inspect their 
 ;; CHECK-NEXT:                                                 contents or call them.
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --preserve-type-order                         Preserve the order of types from
-;; CHECK-NEXT:                                                 the input (useful for debugging
+;; CHECK-NEXT:                                                 the input (useful for debugging 
 ;; CHECK-NEXT:                                                 and testing)
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --generate-stack-ir                           generate StackIR during writing
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --optimize-stack-ir                           optimize StackIR during writing
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --print-stack-ir                              print StackIR during writing
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --no-stack-ir                                 do not use StackIR (even when it
 ;; CHECK-NEXT:                                                 is the default)
-;; CHECK-NEXT:
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT: General options:
 ;; CHECK-NEXT: ----------------
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --version                                     Output version information and
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --version                                     Output version information and 
 ;; CHECK-NEXT:                                                 exit
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --help,-h                                     Show this help message and exit
-;; CHECK-NEXT:
-;; CHECK-NEXT:   --debug,-d                                    Print debug information to
+;; CHECK-EMPTY:
+;; CHECK-NEXT:   --debug,-d                                    Print debug information to 
 ;; CHECK-NEXT:                                                 stderr
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
diff --git a/test/lit/merge/manifest-explicit-name.wat b/test/lit/merge/manifest-explicit-name.wat
index b4f60fa5745..59e2b08874a 100644
--- a/test/lit/merge/manifest-explicit-name.wat
+++ b/test/lit/merge/manifest-explicit-name.wat
@@ -8,7 +8,7 @@
 
 ;; CHECK:      second
 ;; CHECK-NEXT: 0_1
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 
 ;; MERGED:      (module
 ;; MERGED-NEXT:  (type $0 (func))
diff --git a/test/lit/merge/manifest.wat b/test/lit/merge/manifest.wat
index c93b40cdef9..db51cd70306 100644
--- a/test/lit/merge/manifest.wat
+++ b/test/lit/merge/manifest.wat
@@ -9,7 +9,7 @@
 
 ;; CHECK:      second
 ;; CHECK-NEXT: baz
-;; CHECK-NEXT:
+;; CHECK-EMPTY:
 ;; CHECK-NEXT: third
 ;; CHECK-NEXT: qux
 
diff --git a/test/lit/passes/abstract-type-refining-desc.wast b/test/lit/passes/abstract-type-refining-desc.wast
index ae1b6de079a..699b5c46ad2 100644
--- a/test/lit/passes/abstract-type-refining-desc.wast
+++ b/test/lit/passes/abstract-type-refining-desc.wast
@@ -1031,9 +1031,9 @@
     ;; NO_TNH:      (rec
     ;; NO_TNH-NEXT:  (type $A (sub (descriptor $B) (struct)))
     (type $A (sub (descriptor $B) (struct)))
-    ;; YESTNH:       (type $B (describes $A) (struct))
-    ;; NO_TNH:       (type $B (describes $A) (struct))
-    (type $B (describes $A) (struct))
+    ;; YESTNH:       (type $B (sub (describes $A) (struct)))
+    ;; NO_TNH:       (type $B (sub (describes $A) (struct)))
+    (type $B (sub (describes $A) (struct)))
   )
 
   ;; YESTNH:       (type $2 (func (result (ref none))))
diff --git a/test/lit/passes/coalesce-locals.wast b/test/lit/passes/coalesce-locals.wast
index 422c06a818f..555ef3bc633 100644
--- a/test/lit/passes/coalesce-locals.wast
+++ b/test/lit/passes/coalesce-locals.wast
@@ -3101,7 +3101,7 @@
    ;; all. However, we only analyze copied values *inside* blocks, which means
    ;; that in each of the if arms we see that $3 is assigned either the value
    ;; of $1 or $2, but we don't know that those values are both equal to $0. As
-   ;; a result, we will infer that $3 interfers with $0, as their live ranges
+   ;; a result, we will infer that $3 interferes with $0, as their live ranges
    ;; overlap and $3 is assigned a value that looks different than $0. This
    ;; will prevent $3 being coalesced with all the others. (However, see the
    ;; next testcase for more on this.)
diff --git a/test/lit/passes/constraint-analysis-loops.wast b/test/lit/passes/constraint-analysis-loops.wast
index 9c1e594f18e..7c66ee84429 100644
--- a/test/lit/passes/constraint-analysis-loops.wast
+++ b/test/lit/passes/constraint-analysis-loops.wast
@@ -1905,4 +1905,59 @@
       )
     )
   )
+
+  ;; CHECK:      (func $increment-tee (type $0)
+  ;; CHECK-NEXT:  (local $x i32)
+  ;; CHECK-NEXT:  (local $y i32)
+  ;; CHECK-NEXT:  (loop $label1
+  ;; CHECK-NEXT:   (if
+  ;; CHECK-NEXT:    (i32.gt_s
+  ;; CHECK-NEXT:     (local.get $y)
+  ;; CHECK-NEXT:     (local.get $x)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:    (then
+  ;; CHECK-NEXT:     (unreachable)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (local.set $y
+  ;; CHECK-NEXT:    (local.tee $x
+  ;; CHECK-NEXT:     (i32.add
+  ;; CHECK-NEXT:      (local.get $y)
+  ;; CHECK-NEXT:      (i32.const 1)
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (br $label1)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $increment-tee
+    (local $x i32)
+    (local $y i32)
+    ;; A loop, where $y is incremented but there is a tee in the middle. The loop
+    ;; is unbounded (the exit condition is never hit), so we must be careful to
+    ;; not keep calculating 1,2,3, without limit. The tee in the middle should not
+    ;; confuse us: we apply the +=1 operation to x directly, but y reads it
+    ;; through the tee. We should stop calculating anything about both rather than
+    ;; hang for a long time.
+    (loop $label1
+      (if
+        (i32.gt_s
+          (local.get $y)
+          (local.get $x)
+        )
+        (then
+          (unreachable)
+        )
+      )
+      (local.set $y
+        (local.tee $x
+          (i32.add
+            (local.get $y)
+            (i32.const 1)
+          )
+        )
+      )
+      (br $label1)
+    )
+  )
 )
diff --git a/test/lit/passes/constraint-analysis.wast b/test/lit/passes/constraint-analysis.wast
index d5590395f5b..067845236dd 100644
--- a/test/lit/passes/constraint-analysis.wast
+++ b/test/lit/passes/constraint-analysis.wast
@@ -13,6 +13,10 @@
   ;; OPTIN:      (type $array (array (mut i32)))
   (type $array (array (mut i32)))
 
+  ;; CHECK:      (import "a" "b" (func $import (type $4) (result i32)))
+  ;; OPTIN:      (import "a" "b" (func $import (type $4) (result i32)))
+  (import "a" "b" (func $import (result i32)))
+
   ;; CHECK:      (func $simple (type $1)
   ;; CHECK-NEXT:  (local $x i32)
   ;; CHECK-NEXT:  (local.set $x
@@ -1731,7 +1735,7 @@
     )
   )
 
-  ;; CHECK:      (func $br_on_null (type $5) (param $param anyref)
+  ;; CHECK:      (func $br_on_null (type $6) (param $param anyref)
   ;; CHECK-NEXT:  (block $block
   ;; CHECK-NEXT:   (drop
   ;; CHECK-NEXT:    (ref.is_null
@@ -1752,7 +1756,7 @@
   ;; CHECK-NEXT:   (i32.const 1)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT: )
-  ;; OPTIN:      (func $br_on_null (type $5) (param $param anyref)
+  ;; OPTIN:      (func $br_on_null (type $6) (param $param anyref)
   ;; OPTIN-NEXT:  (block $block
   ;; OPTIN-NEXT:   (drop
   ;; OPTIN-NEXT:    (ref.is_null
@@ -1802,7 +1806,7 @@
     )
   )
 
-  ;; CHECK:      (func $br_on_non_null (type $5) (param $param anyref)
+  ;; CHECK:      (func $br_on_non_null (type $6) (param $param anyref)
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (block $block (result (ref any))
   ;; CHECK-NEXT:    (drop
@@ -1823,7 +1827,7 @@
   ;; CHECK-NEXT:   (i32.const 0)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT: )
-  ;; OPTIN:      (func $br_on_non_null (type $5) (param $param anyref)
+  ;; OPTIN:      (func $br_on_non_null (type $6) (param $param anyref)
   ;; OPTIN-NEXT:  (drop
   ;; OPTIN-NEXT:   (block $block (result (ref any))
   ;; OPTIN-NEXT:    (drop
@@ -4457,7 +4461,7 @@
     )
   )
 
-  ;; CHECK:      (func $flipped-contradiction (type $6) (result i32)
+  ;; CHECK:      (func $flipped-contradiction (type $4) (result i32)
   ;; CHECK-NEXT:  (local $x i32)
   ;; CHECK-NEXT:  (loop $loop
   ;; CHECK-NEXT:   (br_if $loop
@@ -4469,7 +4473,7 @@
   ;; CHECK-NEXT:   (unreachable)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT: )
-  ;; OPTIN:      (func $flipped-contradiction (type $6) (result i32)
+  ;; OPTIN:      (func $flipped-contradiction (type $4) (result i32)
   ;; OPTIN-NEXT:  (local $x i32)
   ;; OPTIN-NEXT:  (loop $loop
   ;; OPTIN-NEXT:   (br_if $loop
@@ -4503,7 +4507,7 @@
     )
   )
 
-  ;; CHECK:      (func $flipped-contradiction-no (type $6) (result i32)
+  ;; CHECK:      (func $flipped-contradiction-no (type $4) (result i32)
   ;; CHECK-NEXT:  (local $x i32)
   ;; CHECK-NEXT:  (loop $loop (result i32)
   ;; CHECK-NEXT:   (br_if $loop
@@ -4517,7 +4521,7 @@
   ;; CHECK-NEXT:   )
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT: )
-  ;; OPTIN:      (func $flipped-contradiction-no (type $6) (result i32)
+  ;; OPTIN:      (func $flipped-contradiction-no (type $4) (result i32)
   ;; OPTIN-NEXT:  (local $x i32)
   ;; OPTIN-NEXT:  (loop $loop (result i32)
   ;; OPTIN-NEXT:   (br_if $loop
@@ -5025,4 +5029,1851 @@
       )
     )
   )
-)
+
+  ;; CHECK:      (func $eqz_eqz (type $0) (param $a i32)
+  ;; CHECK-NEXT:  (if
+  ;; CHECK-NEXT:   (i32.eqz
+  ;; CHECK-NEXT:    (i32.eqz
+  ;; CHECK-NEXT:     (local.get $a)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (then
+  ;; CHECK-NEXT:    (drop
+  ;; CHECK-NEXT:     (i32.const 1)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  ;; OPTIN:      (func $eqz_eqz (type $0) (param $a i32)
+  ;; OPTIN-NEXT:  (if
+  ;; OPTIN-NEXT:   (local.get $a)
+  ;; OPTIN-NEXT:   (then
+  ;; OPTIN-NEXT:    (drop
+  ;; OPTIN-NEXT:     (i32.const 1)
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:   )
+  ;; OPTIN-NEXT:  )
+  ;; OPTIN-NEXT: )
+  (func $eqz_eqz (param $a i32)
+    (if
+      ;; !!a => a is not 0.
+      (i32.eqz
+        (i32.eqz
+          (local.get $a)
+        )
+      )
+      (then
+        (drop
+          ;; This is true.
+          (i32.ne
+            (local.get $a)
+            (i32.const 0)
+          )
+        )
+      )
+    )
+  )
+
+  ;; CHECK:      (func $pair (type $2) (param $a i32) (param $b i32)
+  ;; CHECK-NEXT:  (if
+  ;; CHECK-NEXT:   (i32.and
+  ;; CHECK-NEXT:    (i32.eqz
+  ;; CHECK-NEXT:     (local.get $a)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:    (i32.eq
+  ;; CHECK-NEXT:     (local.get $b)
+  ;; CHECK-NEXT:     (i32.const 42)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (then
+  ;; CHECK-NEXT:    (drop
+  ;; CHECK-NEXT:     (i32.const 1)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:    (drop
+  ;; CHECK-NEXT:     (i32.const 1)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:    (drop
+  ;; CHECK-NEXT:     (i32.const 0)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (else
+  ;; CHECK-NEXT:    (drop
+  ;; CHECK-NEXT:     (i32.eq
+  ;; CHECK-NEXT:      (local.get $a)
+  ;; CHECK-NEXT:      (i32.const 0)
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:    (drop
+  ;; CHECK-NEXT:     (i32.eq
+  ;; CHECK-NEXT:      (local.get $b)
+  ;; CHECK-NEXT:      (i32.const 42)
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:    (drop
+  ;; CHECK-NEXT:     (i32.eq
+  ;; CHECK-NEXT:      (local.get $a)
+  ;; CHECK-NEXT:      (i32.const 42)
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:    (drop
+  ;; CHECK-NEXT:     (i32.const 42)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  ;; OPTIN:      (func $pair (type $2) (param $a i32) (param $b i32)
+  ;; OPTIN-NEXT:  (if
+  ;; OPTIN-NEXT:   (i32.and
+  ;; OPTIN-NEXT:    (i32.eqz
+  ;; OPTIN-NEXT:     (local.get $a)
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:    (i32.eq
+  ;; OPTIN-NEXT:     (local.get $b)
+  ;; OPTIN-NEXT:     (i32.const 42)
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:   )
+  ;; OPTIN-NEXT:   (then
+  ;; OPTIN-NEXT:    (drop
+  ;; OPTIN-NEXT:     (i32.const 1)
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:    (drop
+  ;; OPTIN-NEXT:     (i32.const 1)
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:    (drop
+  ;; OPTIN-NEXT:     (i32.const 0)
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:   )
+  ;; OPTIN-NEXT:   (else
+  ;; OPTIN-NEXT:    (drop
+  ;; OPTIN-NEXT:     (i32.eqz
+  ;; OPTIN-NEXT:      (local.get $a)
+  ;; OPTIN-NEXT:     )
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:    (drop
+  ;; OPTIN-NEXT:     (i32.eq
+  ;; OPTIN-NEXT:      (local.get $b)
+  ;; OPTIN-NEXT:      (i32.const 42)
+  ;; OPTIN-NEXT:     )
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:    (drop
+  ;; OPTIN-NEXT:     (i32.eq
+  ;; OPTIN-NEXT:      (local.get $a)
+  ;; OPTIN-NEXT:      (i32.const 42)
+  ;; OPTIN-NEXT:     )
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:    (drop
+  ;; OPTIN-NEXT:     (i32.const 42)
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:   )
+  ;; OPTIN-NEXT:  )
+  ;; OPTIN-NEXT: )
+  (func $pair (param $a i32) (param $b i32)
+    ;; Two constraints in one if condition.
+    (if
+      (i32.and
+        ;; a == 0
+        (i32.eqz
+          (local.get $a)
+        )
+        ;; b == 42
+        (i32.eq
+          (local.get $b)
+          (i32.const 42)
+        )
+      )
+      (then
+        ;; These are all true.
+        (drop
+          (i32.eq
+            (local.get $a)
+            (i32.const 0)
+          )
+        )
+        (drop
+          (i32.eq
+            (local.get $b)
+            (i32.const 42)
+          )
+        )
+        ;; This is not.
+        (drop
+          (i32.eq
+            (local.get $a)
+            (i32.const 42)
+          )
+        )
+      )
+      (else
+        ;; The same expressions as in the (then ..). Here, at least one must be
+        ;; false, not not necessarily all of them, so we infer nothing.
+        (drop
+          (i32.eq
+            (local.get $a)
+            (i32.const 0)
+          )
+        )
+        (drop
+          (i32.eq
+            (local.get $b)
+            (i32.const 42)
+          )
+        )
+        (drop
+          (i32.eq
+            (local.get $a)
+            (i32.const 42)
+          )
+        )
+        ;; A silly extra instruction to stop optimize-instructions from
+        ;; folding the if-else arms.
+        (drop
+          (i32.const 42)
+        )
+      )
+    )
+  )
+
+  ;; CHECK:      (func $pair-same-local (type $0) (param $a i32)
+  ;; CHECK-NEXT:  (if
+  ;; CHECK-NEXT:   (i32.and
+  ;; CHECK-NEXT:    (i32.gt_u
+  ;; CHECK-NEXT:     (local.get $a)
+  ;; CHECK-NEXT:     (i32.const 42)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:    (i32.gt_u
+  ;; CHECK-NEXT:     (local.get $a)
+  ;; CHECK-NEXT:     (i32.const 1337)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (then
+  ;; CHECK-NEXT:    (drop
+  ;; CHECK-NEXT:     (i32.const 1)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (else
+  ;; CHECK-NEXT:    (drop
+  ;; CHECK-NEXT:     (i32.const 1)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  ;; OPTIN:      (func $pair-same-local (type $0) (param $a i32)
+  ;; OPTIN-NEXT:  (drop
+  ;; OPTIN-NEXT:   (if (result i32)
+  ;; OPTIN-NEXT:    (i32.and
+  ;; OPTIN-NEXT:     (i32.gt_u
+  ;; OPTIN-NEXT:      (local.get $a)
+  ;; OPTIN-NEXT:      (i32.const 42)
+  ;; OPTIN-NEXT:     )
+  ;; OPTIN-NEXT:     (i32.gt_u
+  ;; OPTIN-NEXT:      (local.get $a)
+  ;; OPTIN-NEXT:      (i32.const 1337)
+  ;; OPTIN-NEXT:     )
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:    (then
+  ;; OPTIN-NEXT:     (i32.const 1)
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:    (else
+  ;; OPTIN-NEXT:     (i32.const 1)
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:   )
+  ;; OPTIN-NEXT:  )
+  ;; OPTIN-NEXT: )
+  (func $pair-same-local (param $a i32)
+    ;; Similar to above, but now the two ANDed conditions are about the same
+    ;; local
+    (if
+      (i32.and
+        ;; a > 42
+        (i32.gt_u
+          (local.get $a)
+          (i32.const 42)
+        )
+        ;; a > 1337
+        (i32.gt_u
+          (local.get $a)
+          (i32.const 1337)
+        )
+      )
+      (then
+        ;; This is true.
+        (drop
+          (i32.gt_u
+            (local.get $a)
+            (i32.const 1337)
+          )
+        )
+      )
+      (else
+        ;; The negation of  a > 42 && a > 1337  is  a <= 42 || a <= 1337, so we
+        ;; can infer a <= 1337.
+        (drop
+          (i32.le_u
+            (local.get $a)
+            (i32.const 1337)
+          )
+        )
+      )
+    )
+  )
+
+  ;; CHECK:      (func $pair-same-local-bad-or (type $0) (param $a i32)
+  ;; CHECK-NEXT:  (if
+  ;; CHECK-NEXT:   (i32.and
+  ;; CHECK-NEXT:    (i32.ne
+  ;; CHECK-NEXT:     (local.get $a)
+  ;; CHECK-NEXT:     (i32.const 42)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:    (i32.ne
+  ;; CHECK-NEXT:     (local.get $a)
+  ;; CHECK-NEXT:     (i32.const 1337)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (then
+  ;; CHECK-NEXT:    (drop
+  ;; CHECK-NEXT:     (i32.const 1)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:    (drop
+  ;; CHECK-NEXT:     (i32.const 1)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:    (drop
+  ;; CHECK-NEXT:     (i32.ne
+  ;; CHECK-NEXT:      (local.get $a)
+  ;; CHECK-NEXT:      (i32.const 500)
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (else
+  ;; CHECK-NEXT:    (drop
+  ;; CHECK-NEXT:     (i32.eq
+  ;; CHECK-NEXT:      (local.get $a)
+  ;; CHECK-NEXT:      (i32.const 42)
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:    (drop
+  ;; CHECK-NEXT:     (i32.eq
+  ;; CHECK-NEXT:      (local.get $a)
+  ;; CHECK-NEXT:      (i32.const 1337)
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:    (drop
+  ;; CHECK-NEXT:     (i32.eq
+  ;; CHECK-NEXT:      (local.get $a)
+  ;; CHECK-NEXT:      (i32.const 500)
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  ;; OPTIN:      (func $pair-same-local-bad-or (type $0) (param $a i32)
+  ;; OPTIN-NEXT:  (if
+  ;; OPTIN-NEXT:   (i32.and
+  ;; OPTIN-NEXT:    (i32.ne
+  ;; OPTIN-NEXT:     (local.get $a)
+  ;; OPTIN-NEXT:     (i32.const 42)
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:    (i32.ne
+  ;; OPTIN-NEXT:     (local.get $a)
+  ;; OPTIN-NEXT:     (i32.const 1337)
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:   )
+  ;; OPTIN-NEXT:   (then
+  ;; OPTIN-NEXT:    (drop
+  ;; OPTIN-NEXT:     (i32.const 1)
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:    (drop
+  ;; OPTIN-NEXT:     (i32.const 1)
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:    (drop
+  ;; OPTIN-NEXT:     (i32.ne
+  ;; OPTIN-NEXT:      (local.get $a)
+  ;; OPTIN-NEXT:      (i32.const 500)
+  ;; OPTIN-NEXT:     )
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:   )
+  ;; OPTIN-NEXT:   (else
+  ;; OPTIN-NEXT:    (drop
+  ;; OPTIN-NEXT:     (i32.eq
+  ;; OPTIN-NEXT:      (local.get $a)
+  ;; OPTIN-NEXT:      (i32.const 42)
+  ;; OPTIN-NEXT:     )
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:    (drop
+  ;; OPTIN-NEXT:     (i32.eq
+  ;; OPTIN-NEXT:      (local.get $a)
+  ;; OPTIN-NEXT:      (i32.const 1337)
+  ;; OPTIN-NEXT:     )
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:    (drop
+  ;; OPTIN-NEXT:     (i32.eq
+  ;; OPTIN-NEXT:      (local.get $a)
+  ;; OPTIN-NEXT:      (i32.const 500)
+  ;; OPTIN-NEXT:     )
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:   )
+  ;; OPTIN-NEXT:  )
+  ;; OPTIN-NEXT: )
+  (func $pair-same-local-bad-or (param $a i32)
+    ;; As above, but the OR we do for the else fails.
+    (if
+      (i32.and
+        ;; a != 42 && a != 1337
+        (i32.ne
+          (local.get $a)
+          (i32.const 42)
+        )
+        (i32.ne
+          (local.get $a)
+          (i32.const 1337)
+        )
+      )
+      (then
+        ;; These are true.
+        (drop
+          (i32.ne
+            (local.get $a)
+            (i32.const 42)
+          )
+        )
+        (drop
+          (i32.ne
+            (local.get $a)
+            (i32.const 1337)
+          )
+        )
+        ;; This is unknown.
+        (drop
+          (i32.ne
+            (local.get $a)
+            (i32.const 500)
+          )
+        )
+      )
+      (else
+        ;; ORing a == 42 || a == 1337, we get nothing useful, and can prove
+        ;; nothing. TODO: we could infer a span here
+        (drop
+          (i32.eq
+            (local.get $a)
+            (i32.const 42)
+          )
+        )
+        (drop
+          (i32.eq
+            (local.get $a)
+            (i32.const 1337)
+          )
+        )
+        (drop
+          (i32.eq
+            (local.get $a)
+            (i32.const 500)
+          )
+        )
+      )
+    )
+  )
+
+  ;; CHECK:      (func $pair-partial (type $0) (param $a i32)
+  ;; CHECK-NEXT:  (if
+  ;; CHECK-NEXT:   (i32.and
+  ;; CHECK-NEXT:    (i32.eq
+  ;; CHECK-NEXT:     (local.get $a)
+  ;; CHECK-NEXT:     (i32.const 42)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:    (call $import)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (then
+  ;; CHECK-NEXT:    (drop
+  ;; CHECK-NEXT:     (i32.const 1)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (else
+  ;; CHECK-NEXT:    (drop
+  ;; CHECK-NEXT:     (i32.eq
+  ;; CHECK-NEXT:      (local.get $a)
+  ;; CHECK-NEXT:      (i32.const 42)
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:    (drop
+  ;; CHECK-NEXT:     (i32.const 42)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  ;; OPTIN:      (func $pair-partial (type $0) (param $a i32)
+  ;; OPTIN-NEXT:  (if
+  ;; OPTIN-NEXT:   (i32.and
+  ;; OPTIN-NEXT:    (call $import)
+  ;; OPTIN-NEXT:    (i32.eq
+  ;; OPTIN-NEXT:     (local.get $a)
+  ;; OPTIN-NEXT:     (i32.const 42)
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:   )
+  ;; OPTIN-NEXT:   (then
+  ;; OPTIN-NEXT:    (drop
+  ;; OPTIN-NEXT:     (i32.const 1)
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:   )
+  ;; OPTIN-NEXT:   (else
+  ;; OPTIN-NEXT:    (drop
+  ;; OPTIN-NEXT:     (i32.eq
+  ;; OPTIN-NEXT:      (local.get $a)
+  ;; OPTIN-NEXT:      (i32.const 42)
+  ;; OPTIN-NEXT:     )
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:    (drop
+  ;; OPTIN-NEXT:     (i32.const 42)
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:   )
+  ;; OPTIN-NEXT:  )
+  ;; OPTIN-NEXT: )
+  (func $pair-partial (param $a i32)
+    (if
+      (i32.and
+        ;; a == 42
+        (i32.eq
+          (local.get $a)
+          (i32.const 42)
+        )
+        ;; ANDed with something we know nothing about
+        (call $import)
+      )
+      (then
+        ;; a must be 42, to get here.
+        (drop
+          (i32.eq
+            (local.get $a)
+            (i32.const 42)
+          )
+        )
+      )
+      (else
+        ;; But we don't know anything about a here: we get to this place when
+        ;; a != 42 OR the unknown was 0, so a could be anything.
+        (drop
+          (i32.eq
+            (local.get $a)
+            (i32.const 42)
+          )
+        )
+        ;; A silly extra instruction to stop optimize-instructions from
+        ;; folding the if-else arms.
+        (drop
+          (i32.const 42)
+        )
+      )
+    )
+  )
+
+  ;; CHECK:      (func $several (type $11) (param $a i32) (param $b i32) (param $c i32) (param $d i32) (param $e i32)
+  ;; CHECK-NEXT:  (if
+  ;; CHECK-NEXT:   (i32.and
+  ;; CHECK-NEXT:    (i32.and
+  ;; CHECK-NEXT:     (i32.eqz
+  ;; CHECK-NEXT:      (i32.eqz
+  ;; CHECK-NEXT:       (local.get $a)
+  ;; CHECK-NEXT:      )
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:     (i32.eq
+  ;; CHECK-NEXT:      (local.get $b)
+  ;; CHECK-NEXT:      (i32.const 10)
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:    (i32.and
+  ;; CHECK-NEXT:     (i32.eq
+  ;; CHECK-NEXT:      (local.get $d)
+  ;; CHECK-NEXT:      (i32.const 20)
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:     (i32.eq
+  ;; CHECK-NEXT:      (local.get $e)
+  ;; CHECK-NEXT:      (i32.const 30)
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (then
+  ;; CHECK-NEXT:    (drop
+  ;; CHECK-NEXT:     (i32.const 1)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:    (drop
+  ;; CHECK-NEXT:     (i32.const 1)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:    (drop
+  ;; CHECK-NEXT:     (i32.const 1)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:    (drop
+  ;; CHECK-NEXT:     (i32.const 1)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:    (drop
+  ;; CHECK-NEXT:     (i32.const 0)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:    (drop
+  ;; CHECK-NEXT:     (i32.eq
+  ;; CHECK-NEXT:      (local.get $c)
+  ;; CHECK-NEXT:      (i32.const 40)
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  ;; OPTIN:      (func $several (type $11) (param $a i32) (param $b i32) (param $c i32) (param $d i32) (param $e i32)
+  ;; OPTIN-NEXT:  (if
+  ;; OPTIN-NEXT:   (i32.and
+  ;; OPTIN-NEXT:    (i32.and
+  ;; OPTIN-NEXT:     (i32.eq
+  ;; OPTIN-NEXT:      (local.get $b)
+  ;; OPTIN-NEXT:      (i32.const 10)
+  ;; OPTIN-NEXT:     )
+  ;; OPTIN-NEXT:     (i32.ne
+  ;; OPTIN-NEXT:      (local.get $a)
+  ;; OPTIN-NEXT:      (i32.const 0)
+  ;; OPTIN-NEXT:     )
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:    (i32.and
+  ;; OPTIN-NEXT:     (i32.eq
+  ;; OPTIN-NEXT:      (local.get $d)
+  ;; OPTIN-NEXT:      (i32.const 20)
+  ;; OPTIN-NEXT:     )
+  ;; OPTIN-NEXT:     (i32.eq
+  ;; OPTIN-NEXT:      (local.get $e)
+  ;; OPTIN-NEXT:      (i32.const 30)
+  ;; OPTIN-NEXT:     )
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:   )
+  ;; OPTIN-NEXT:   (then
+  ;; OPTIN-NEXT:    (drop
+  ;; OPTIN-NEXT:     (i32.const 1)
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:    (drop
+  ;; OPTIN-NEXT:     (i32.const 1)
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:    (drop
+  ;; OPTIN-NEXT:     (i32.const 1)
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:    (drop
+  ;; OPTIN-NEXT:     (i32.const 1)
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:    (drop
+  ;; OPTIN-NEXT:     (i32.const 0)
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:    (drop
+  ;; OPTIN-NEXT:     (i32.eq
+  ;; OPTIN-NEXT:      (local.get $c)
+  ;; OPTIN-NEXT:      (i32.const 40)
+  ;; OPTIN-NEXT:     )
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:   )
+  ;; OPTIN-NEXT:  )
+  ;; OPTIN-NEXT: )
+  (func $several (param $a i32) (param $b i32) (param $c i32) (param $d i32) (param $e i32)
+    ;; Four constraints in one if condition.
+    (if
+      (i32.and
+        (i32.and
+          ;; !!a => a is not 0.
+          (i32.eqz
+            (i32.eqz
+              (local.get $a)
+            )
+          )
+          ;; b == 10
+          (i32.eq
+            (local.get $b)
+            (i32.const 10)
+          )
+        )
+        (i32.and
+          ;; d == 20
+          (i32.eq
+            (local.get $d)
+            (i32.const 20)
+          )
+          ;; e == 30
+          (i32.eq
+            (local.get $e)
+            (i32.const 30)
+          )
+        )
+      )
+      (then
+        ;; These are all true.
+        (drop
+          (i32.ne
+            (local.get $a)
+            (i32.const 0)
+          )
+        )
+        (drop
+          (i32.eq
+            (local.get $b)
+            (i32.const 10)
+          )
+        )
+        (drop
+          (i32.eq
+            (local.get $d)
+            (i32.const 20)
+          )
+        )
+        (drop
+          (i32.eq
+            (local.get $e)
+            (i32.const 30)
+          )
+        )
+        ;; This is false.
+        (drop
+          (i32.eq
+            (local.get $a)
+            (i32.const 0)
+          )
+        )
+        ;; This local is unknown.
+        (drop
+          (i32.eq
+            (local.get $c)
+            (i32.const 40)
+          )
+        )
+      )
+    )
+  )
+
+  ;; CHECK:      (func $three.contradiction.middle (type $0) (param $x i32)
+  ;; CHECK-NEXT:  (if
+  ;; CHECK-NEXT:   (i32.and
+  ;; CHECK-NEXT:    (i32.eqz
+  ;; CHECK-NEXT:     (local.get $x)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:    (i32.and
+  ;; CHECK-NEXT:     (i32.lt_s
+  ;; CHECK-NEXT:      (local.get $x)
+  ;; CHECK-NEXT:      (i32.const 0)
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:     (i32.ge_s
+  ;; CHECK-NEXT:      (local.get $x)
+  ;; CHECK-NEXT:      (i32.const 0)
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (then
+  ;; CHECK-NEXT:    (drop
+  ;; CHECK-NEXT:     (unreachable)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  ;; OPTIN:      (func $three.contradiction.middle (type $0) (param $x i32)
+  ;; OPTIN-NEXT:  (if
+  ;; OPTIN-NEXT:   (i32.and
+  ;; OPTIN-NEXT:    (i32.eqz
+  ;; OPTIN-NEXT:     (local.get $x)
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:    (i32.and
+  ;; OPTIN-NEXT:     (i32.lt_s
+  ;; OPTIN-NEXT:      (local.get $x)
+  ;; OPTIN-NEXT:      (i32.const 0)
+  ;; OPTIN-NEXT:     )
+  ;; OPTIN-NEXT:     (i32.ge_s
+  ;; OPTIN-NEXT:      (local.get $x)
+  ;; OPTIN-NEXT:      (i32.const 0)
+  ;; OPTIN-NEXT:     )
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:   )
+  ;; OPTIN-NEXT:   (then
+  ;; OPTIN-NEXT:    (drop
+  ;; OPTIN-NEXT:     (unreachable)
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:   )
+  ;; OPTIN-NEXT:  )
+  ;; OPTIN-NEXT: )
+  (func $three.contradiction.middle (param $x i32)
+    ;; First we set x == 0, then x < 0, then x >= 0. The first two are a
+    ;; contradiction. We should not error (after a contradiction, we should not
+    ;; apply further constraints), and can optimize away the if body.
+    (if
+      (i32.and
+        (i32.eqz
+          (local.get $x)
+        )
+        (i32.and
+          (i32.lt_s
+            (local.get $x)
+            (i32.const 0)
+          )
+          (i32.ge_s
+            (local.get $x)
+            (i32.const 0)
+          )
+        )
+      )
+      (then
+        (drop
+          (i32.eqz
+            (local.get $x)
+          )
+        )
+      )
+    )
+  )
+
+  ;; CHECK:      (func $br_if_and (type $0) (param $param i32)
+  ;; CHECK-NEXT:  (block $block
+  ;; CHECK-NEXT:   (br_if $block
+  ;; CHECK-NEXT:    (i32.and
+  ;; CHECK-NEXT:     (i32.ne
+  ;; CHECK-NEXT:      (local.get $param)
+  ;; CHECK-NEXT:      (i32.const 10)
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:     (i32.ne
+  ;; CHECK-NEXT:      (local.get $param)
+  ;; CHECK-NEXT:      (i32.const 20)
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (return)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT:  (drop
+  ;; CHECK-NEXT:   (i32.and
+  ;; CHECK-NEXT:    (i32.const 1)
+  ;; CHECK-NEXT:    (i32.const 1)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT:  (drop
+  ;; CHECK-NEXT:   (i32.ne
+  ;; CHECK-NEXT:    (local.get $param)
+  ;; CHECK-NEXT:    (i32.const 30)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  ;; OPTIN:      (func $br_if_and (type $0) (param $param i32)
+  ;; OPTIN-NEXT:  (block $block
+  ;; OPTIN-NEXT:   (br_if $block
+  ;; OPTIN-NEXT:    (i32.and
+  ;; OPTIN-NEXT:     (i32.ne
+  ;; OPTIN-NEXT:      (local.get $param)
+  ;; OPTIN-NEXT:      (i32.const 10)
+  ;; OPTIN-NEXT:     )
+  ;; OPTIN-NEXT:     (i32.ne
+  ;; OPTIN-NEXT:      (local.get $param)
+  ;; OPTIN-NEXT:      (i32.const 20)
+  ;; OPTIN-NEXT:     )
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:   )
+  ;; OPTIN-NEXT:   (return)
+  ;; OPTIN-NEXT:  )
+  ;; OPTIN-NEXT:  (drop
+  ;; OPTIN-NEXT:   (i32.and
+  ;; OPTIN-NEXT:    (i32.const 1)
+  ;; OPTIN-NEXT:    (i32.const 1)
+  ;; OPTIN-NEXT:   )
+  ;; OPTIN-NEXT:  )
+  ;; OPTIN-NEXT:  (drop
+  ;; OPTIN-NEXT:   (i32.ne
+  ;; OPTIN-NEXT:    (local.get $param)
+  ;; OPTIN-NEXT:    (i32.const 30)
+  ;; OPTIN-NEXT:   )
+  ;; OPTIN-NEXT:  )
+  ;; OPTIN-NEXT: )
+  (func $br_if_and (param $param i32)
+    ;; An AND in a br_if condition.
+    (block $block
+      (br_if $block
+        (i32.and
+          (i32.ne
+            (local.get $param)
+            (i32.const 10)
+          )
+          (i32.ne
+            (local.get $param)
+            (i32.const 20)
+          )
+        )
+      )
+      (return)
+    )
+    ;; If we get here, param != 10 && param != 20. We optimize each arm of the
+    ;; AND here.
+    (drop
+      (i32.and
+        (i32.ne
+          (local.get $param)
+          (i32.const 10)
+        )
+        (i32.ne
+          (local.get $param)
+          (i32.const 20)
+        )
+      )
+    )
+    ;; This one we don't know.
+    (drop
+      (i32.ne
+        (local.get $param)
+        (i32.const 30)
+      )
+    )
+  )
+
+  ;; CHECK:      (func $tee-condition (type $0) (param $x i32)
+  ;; CHECK-NEXT:  (if
+  ;; CHECK-NEXT:   (i32.eq
+  ;; CHECK-NEXT:    (local.tee $x
+  ;; CHECK-NEXT:     (call $import)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:    (i32.const 42)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (then
+  ;; CHECK-NEXT:    (drop
+  ;; CHECK-NEXT:     (i32.const 0)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  ;; OPTIN:      (func $tee-condition (type $0) (param $x i32)
+  ;; OPTIN-NEXT:  (if
+  ;; OPTIN-NEXT:   (i32.eq
+  ;; OPTIN-NEXT:    (local.tee $x
+  ;; OPTIN-NEXT:     (call $import)
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:    (i32.const 42)
+  ;; OPTIN-NEXT:   )
+  ;; OPTIN-NEXT:   (then
+  ;; OPTIN-NEXT:    (drop
+  ;; OPTIN-NEXT:     (i32.const 0)
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:   )
+  ;; OPTIN-NEXT:  )
+  ;; OPTIN-NEXT: )
+  (func $tee-condition (param $x i32)
+    ;; We can parse the tee in the condition below. The constraint is saying
+    ;; $x == 42.
+    (if
+      (i32.eq
+        (local.tee $x
+          (call $import)
+        )
+        (i32.const 42)
+      )
+      (then
+        ;; $x == 42, so this is false.
+        (drop
+          (i32.eqz
+            (local.get $x)
+          )
+        )
+      )
+    )
+  )
+
+  ;; CHECK:      (func $tee-condition-later-get (type $0) (param $x i32)
+  ;; CHECK-NEXT:  (if
+  ;; CHECK-NEXT:   (i32.and
+  ;; CHECK-NEXT:    (i32.ne
+  ;; CHECK-NEXT:     (local.tee $x
+  ;; CHECK-NEXT:      (call $import)
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:     (i32.const 42)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:    (i32.ne
+  ;; CHECK-NEXT:     (local.get $x)
+  ;; CHECK-NEXT:     (i32.const 1337)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (then
+  ;; CHECK-NEXT:    (drop
+  ;; CHECK-NEXT:     (i32.const 1)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:    (drop
+  ;; CHECK-NEXT:     (i32.const 1)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  ;; OPTIN:      (func $tee-condition-later-get (type $0) (param $x i32)
+  ;; OPTIN-NEXT:  (if
+  ;; OPTIN-NEXT:   (i32.and
+  ;; OPTIN-NEXT:    (i32.ne
+  ;; OPTIN-NEXT:     (local.tee $x
+  ;; OPTIN-NEXT:      (call $import)
+  ;; OPTIN-NEXT:     )
+  ;; OPTIN-NEXT:     (i32.const 42)
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:    (i32.ne
+  ;; OPTIN-NEXT:     (local.get $x)
+  ;; OPTIN-NEXT:     (i32.const 1337)
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:   )
+  ;; OPTIN-NEXT:   (then
+  ;; OPTIN-NEXT:    (drop
+  ;; OPTIN-NEXT:     (i32.const 1)
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:    (drop
+  ;; OPTIN-NEXT:     (i32.const 1)
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:   )
+  ;; OPTIN-NEXT:  )
+  ;; OPTIN-NEXT: )
+  (func $tee-condition-later-get (param $x i32)
+    ;; The nested ANDs here include a tee and a later get, which is fine.
+    (if
+      (i32.and
+        (i32.ne
+          (local.tee $x
+            (call $import)
+          )
+          (i32.const 42)
+        )
+        (i32.ne
+          (local.get $x)
+          (i32.const 1337)
+        )
+      )
+      (then
+        ;; $x != 42 && $x != 1337, so these are true.
+        (drop
+          (i32.ne
+            (local.get $x)
+            (i32.const 42)
+          )
+        )
+        (drop
+          (i32.ne
+            (local.get $x)
+            (i32.const 1337)
+          )
+        )
+      )
+    )
+  )
+
+  ;; CHECK:      (func $tee-condition-later-get-2 (type $0) (param $x i32)
+  ;; CHECK-NEXT:  (if
+  ;; CHECK-NEXT:   (block (result i32)
+  ;; CHECK-NEXT:    (drop
+  ;; CHECK-NEXT:     (local.tee $x
+  ;; CHECK-NEXT:      (i32.const 42)
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:    (i32.const 1)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (then
+  ;; CHECK-NEXT:    (drop
+  ;; CHECK-NEXT:     (i32.const 1)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  ;; OPTIN:      (func $tee-condition-later-get-2 (type $0) (param $x i32)
+  ;; OPTIN-NEXT:  (if
+  ;; OPTIN-NEXT:   (block (result i32)
+  ;; OPTIN-NEXT:    (drop
+  ;; OPTIN-NEXT:     (local.tee $x
+  ;; OPTIN-NEXT:      (i32.const 42)
+  ;; OPTIN-NEXT:     )
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:    (i32.const 1)
+  ;; OPTIN-NEXT:   )
+  ;; OPTIN-NEXT:   (then
+  ;; OPTIN-NEXT:    (drop
+  ;; OPTIN-NEXT:     (i32.const 1)
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:   )
+  ;; OPTIN-NEXT:  )
+  ;; OPTIN-NEXT: )
+  (func $tee-condition-later-get-2 (param $x i32)
+    ;; A later get without two ANDs - in the same comparison. We can infer the
+    ;; comparison is 1.
+    (if
+      (i32.eq
+        (local.tee $x
+          (i32.const 42)
+        )
+        (local.get $x)
+      )
+      (then
+        ;; $x == 42, so this is true.
+        (drop
+          (i32.eq
+            (local.get $x)
+            (i32.const 42)
+          )
+        )
+      )
+    )
+  )
+  ;; CHECK:      (func $tee-condition-later-tee (type $0) (param $x i32)
+  ;; CHECK-NEXT:  (if
+  ;; CHECK-NEXT:   (i32.and
+  ;; CHECK-NEXT:    (i32.ne
+  ;; CHECK-NEXT:     (local.get $x)
+  ;; CHECK-NEXT:     (i32.const 42)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:    (i32.ne
+  ;; CHECK-NEXT:     (local.tee $x
+  ;; CHECK-NEXT:      (call $import)
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:     (i32.const 1337)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (then
+  ;; CHECK-NEXT:    (drop
+  ;; CHECK-NEXT:     (i32.ne
+  ;; CHECK-NEXT:      (local.get $x)
+  ;; CHECK-NEXT:      (i32.const 42)
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:    (drop
+  ;; CHECK-NEXT:     (i32.ne
+  ;; CHECK-NEXT:      (local.get $x)
+  ;; CHECK-NEXT:      (i32.const 1337)
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  ;; OPTIN:      (func $tee-condition-later-tee (type $0) (param $x i32)
+  ;; OPTIN-NEXT:  (if
+  ;; OPTIN-NEXT:   (i32.and
+  ;; OPTIN-NEXT:    (i32.ne
+  ;; OPTIN-NEXT:     (local.get $x)
+  ;; OPTIN-NEXT:     (i32.const 42)
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:    (i32.ne
+  ;; OPTIN-NEXT:     (local.tee $x
+  ;; OPTIN-NEXT:      (call $import)
+  ;; OPTIN-NEXT:     )
+  ;; OPTIN-NEXT:     (i32.const 1337)
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:   )
+  ;; OPTIN-NEXT:   (then
+  ;; OPTIN-NEXT:    (drop
+  ;; OPTIN-NEXT:     (i32.ne
+  ;; OPTIN-NEXT:      (local.get $x)
+  ;; OPTIN-NEXT:      (i32.const 42)
+  ;; OPTIN-NEXT:     )
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:    (drop
+  ;; OPTIN-NEXT:     (i32.ne
+  ;; OPTIN-NEXT:      (local.get $x)
+  ;; OPTIN-NEXT:      (i32.const 1337)
+  ;; OPTIN-NEXT:     )
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:   )
+  ;; OPTIN-NEXT:  )
+  ;; OPTIN-NEXT: )
+  (func $tee-condition-later-tee (param $x i32)
+    ;; Reverse the tee and get order. $x appears twice, with two different
+    ;; values, so we give up here.
+    ;; TODO: use SSA
+    (if
+      (i32.and
+        (i32.ne
+          (local.get $x)
+          (i32.const 42)
+        )
+        (i32.ne
+          (local.tee $x
+            (call $import)
+          )
+          (i32.const 1337)
+        )
+      )
+      (then
+        ;; We infer nothing here TODO: we could infer the last
+        (drop
+          (i32.ne
+            (local.get $x)
+            (i32.const 42)
+          )
+        )
+        (drop
+          (i32.ne
+            (local.get $x)
+            (i32.const 1337)
+          )
+        )
+      )
+    )
+  )
+
+  ;; CHECK:      (func $tee-condition-later-tee-different-local (type $2) (param $x i32) (param $y i32)
+  ;; CHECK-NEXT:  (if
+  ;; CHECK-NEXT:   (i32.and
+  ;; CHECK-NEXT:    (i32.ne
+  ;; CHECK-NEXT:     (local.get $x)
+  ;; CHECK-NEXT:     (i32.const 42)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:    (i32.ne
+  ;; CHECK-NEXT:     (local.tee $y
+  ;; CHECK-NEXT:      (call $import)
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:     (i32.const 1337)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (then
+  ;; CHECK-NEXT:    (drop
+  ;; CHECK-NEXT:     (i32.const 1)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:    (drop
+  ;; CHECK-NEXT:     (i32.const 1)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  ;; OPTIN:      (func $tee-condition-later-tee-different-local (type $2) (param $x i32) (param $y i32)
+  ;; OPTIN-NEXT:  (if
+  ;; OPTIN-NEXT:   (i32.and
+  ;; OPTIN-NEXT:    (i32.ne
+  ;; OPTIN-NEXT:     (local.get $x)
+  ;; OPTIN-NEXT:     (i32.const 42)
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:    (i32.ne
+  ;; OPTIN-NEXT:     (local.tee $y
+  ;; OPTIN-NEXT:      (call $import)
+  ;; OPTIN-NEXT:     )
+  ;; OPTIN-NEXT:     (i32.const 1337)
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:   )
+  ;; OPTIN-NEXT:   (then
+  ;; OPTIN-NEXT:    (drop
+  ;; OPTIN-NEXT:     (i32.const 1)
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:    (drop
+  ;; OPTIN-NEXT:     (i32.const 1)
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:   )
+  ;; OPTIN-NEXT:  )
+  ;; OPTIN-NEXT: )
+  (func $tee-condition-later-tee-different-local (param $x i32) (param $y i32)
+    ;; As above, a get and a tee that look like they interfere, but now the
+    ;; local indexes are different. This is fine.
+    (if
+      (i32.and
+        (i32.ne
+          (local.get $x)
+          (i32.const 42)
+        )
+        (i32.ne
+          (local.tee $y
+            (call $import)
+          )
+          (i32.const 1337)
+        )
+      )
+      (then
+        ;; $x != 42 && $y != 1337, so these are true.
+        (drop
+          (i32.ne
+            (local.get $x)
+            (i32.const 42)
+          )
+        )
+        (drop
+          (i32.ne
+            (local.get $y)
+            (i32.const 1337)
+          )
+        )
+      )
+    )
+  )
+
+  ;; CHECK:      (func $tee-condition-eqz (type $0) (param $x i32)
+  ;; CHECK-NEXT:  (if
+  ;; CHECK-NEXT:   (i32.eqz
+  ;; CHECK-NEXT:    (local.tee $x
+  ;; CHECK-NEXT:     (call $import)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (then
+  ;; CHECK-NEXT:    (drop
+  ;; CHECK-NEXT:     (i32.const 1)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  ;; OPTIN:      (func $tee-condition-eqz (type $0) (param $x i32)
+  ;; OPTIN-NEXT:  (if
+  ;; OPTIN-NEXT:   (i32.eqz
+  ;; OPTIN-NEXT:    (local.tee $x
+  ;; OPTIN-NEXT:     (call $import)
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:   )
+  ;; OPTIN-NEXT:   (then
+  ;; OPTIN-NEXT:    (drop
+  ;; OPTIN-NEXT:     (i32.const 1)
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:   )
+  ;; OPTIN-NEXT:  )
+  ;; OPTIN-NEXT: )
+  (func $tee-condition-eqz (param $x i32)
+    ;; Testing for parsing of tee in an eqz.
+    (if
+      (i32.eqz
+        (local.tee $x
+          (call $import)
+        )
+      )
+      (then
+        ;; This is true.
+        (drop
+          (i32.eqz
+            (local.get $x)
+          )
+        )
+      )
+    )
+  )
+
+  ;; CHECK:      (func $tee-condition-eqz-eqz (type $0) (param $x i32)
+  ;; CHECK-NEXT:  (if
+  ;; CHECK-NEXT:   (i32.eqz
+  ;; CHECK-NEXT:    (i32.eqz
+  ;; CHECK-NEXT:     (local.tee $x
+  ;; CHECK-NEXT:      (call $import)
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (then
+  ;; CHECK-NEXT:    (drop
+  ;; CHECK-NEXT:     (i32.const 0)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  ;; OPTIN:      (func $tee-condition-eqz-eqz (type $0) (param $x i32)
+  ;; OPTIN-NEXT:  (if
+  ;; OPTIN-NEXT:   (local.tee $x
+  ;; OPTIN-NEXT:    (call $import)
+  ;; OPTIN-NEXT:   )
+  ;; OPTIN-NEXT:   (then
+  ;; OPTIN-NEXT:    (drop
+  ;; OPTIN-NEXT:     (i32.const 0)
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:   )
+  ;; OPTIN-NEXT:  )
+  ;; OPTIN-NEXT: )
+  (func $tee-condition-eqz-eqz (param $x i32)
+    ;; Testing for parsing of tee in an eqz^2. In the OPTIN case, the double
+    ;; eqz is optimized out, and we test a bare local.tee in a condition.
+    (if
+      (i32.eqz
+        (i32.eqz
+          (local.tee $x
+            (call $import)
+          )
+        )
+      )
+      (then
+        ;; This is false.
+        (drop
+          (i32.eqz
+            (local.get $x)
+          )
+        )
+      )
+    )
+  )
+
+  ;; CHECK:      (func $tee-test (type $0) (param $x i32)
+  ;; CHECK-NEXT:  (if
+  ;; CHECK-NEXT:   (i32.eq
+  ;; CHECK-NEXT:    (local.get $x)
+  ;; CHECK-NEXT:    (i32.const 42)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (then
+  ;; CHECK-NEXT:    (drop
+  ;; CHECK-NEXT:     (i32.eqz
+  ;; CHECK-NEXT:      (local.tee $x
+  ;; CHECK-NEXT:       (call $import)
+  ;; CHECK-NEXT:      )
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  ;; OPTIN:      (func $tee-test (type $0) (param $x i32)
+  ;; OPTIN-NEXT:  (if
+  ;; OPTIN-NEXT:   (i32.eq
+  ;; OPTIN-NEXT:    (local.get $x)
+  ;; OPTIN-NEXT:    (i32.const 42)
+  ;; OPTIN-NEXT:   )
+  ;; OPTIN-NEXT:   (then
+  ;; OPTIN-NEXT:    (drop
+  ;; OPTIN-NEXT:     (i32.eqz
+  ;; OPTIN-NEXT:      (local.tee $x
+  ;; OPTIN-NEXT:       (call $import)
+  ;; OPTIN-NEXT:      )
+  ;; OPTIN-NEXT:     )
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:   )
+  ;; OPTIN-NEXT:  )
+  ;; OPTIN-NEXT: )
+  (func $tee-test (param $x i32)
+    ;; A tee not in the condition, but in the test that we want to optimize.
+    (if
+      ;; $x == 42.
+      (i32.eq
+        (local.get $x)
+        (i32.const 42)
+      )
+      (then
+        ;; The $x being tested is not the same as the one the constraint was on,
+        ;; so we do not optimize.
+        (drop
+          (i32.eqz
+            (local.tee $x
+              (call $import)
+            )
+          )
+        )
+      )
+    )
+  )
+
+  ;; CHECK:      (func $tee-condition-another (type $0) (param $x i32)
+  ;; CHECK-NEXT:  (if
+  ;; CHECK-NEXT:   (i32.ne
+  ;; CHECK-NEXT:    (local.tee $x
+  ;; CHECK-NEXT:     (i32.const 0)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:    (local.tee $x
+  ;; CHECK-NEXT:     (i32.const 1)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (then
+  ;; CHECK-NEXT:    (drop
+  ;; CHECK-NEXT:     (i32.const 1)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  ;; OPTIN:      (func $tee-condition-another (type $0) (param $x i32)
+  ;; OPTIN-NEXT:  (if
+  ;; OPTIN-NEXT:   (i32.ne
+  ;; OPTIN-NEXT:    (local.tee $x
+  ;; OPTIN-NEXT:     (i32.const 0)
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:    (local.tee $x
+  ;; OPTIN-NEXT:     (i32.const 1)
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:   )
+  ;; OPTIN-NEXT:   (then
+  ;; OPTIN-NEXT:    (drop
+  ;; OPTIN-NEXT:     (i32.const 1)
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:   )
+  ;; OPTIN-NEXT:  )
+  ;; OPTIN-NEXT: )
+  (func $tee-condition-another (param $x i32)
+    ;; Two tees of the same local.
+    (if
+      (i32.ne
+        (local.tee $x
+          (i32.const 0)
+        )
+        (local.tee $x
+          (i32.const 1)
+        )
+      )
+      (then
+        ;; We know that $x == 1 here (the last tee; first should not confuse
+        ;; us).
+        (drop
+          (i32.eq
+            (local.get $x)
+            (i32.const 1)
+          )
+        )
+      )
+    )
+  )
+
+  ;; CHECK:      (func $tee-condition-nested (type $2) (param $x i32) (param $y i32)
+  ;; CHECK-NEXT:  (if
+  ;; CHECK-NEXT:   (i32.and
+  ;; CHECK-NEXT:    (i32.eq
+  ;; CHECK-NEXT:     (local.get $x)
+  ;; CHECK-NEXT:     (i32.const 10)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:    (i32.eq
+  ;; CHECK-NEXT:     (local.tee $y
+  ;; CHECK-NEXT:      (block (result i32)
+  ;; CHECK-NEXT:       (local.set $x
+  ;; CHECK-NEXT:        (i32.const 20)
+  ;; CHECK-NEXT:       )
+  ;; CHECK-NEXT:       (call $import)
+  ;; CHECK-NEXT:      )
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:     (i32.const 30)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (then
+  ;; CHECK-NEXT:    (drop
+  ;; CHECK-NEXT:     (i32.const 0)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:    (drop
+  ;; CHECK-NEXT:     (i32.const 1)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:    (drop
+  ;; CHECK-NEXT:     (i32.eq
+  ;; CHECK-NEXT:      (local.get $y)
+  ;; CHECK-NEXT:      (i32.const 30)
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  ;; OPTIN:      (func $tee-condition-nested (type $2) (param $x i32) (param $y i32)
+  ;; OPTIN-NEXT:  (if
+  ;; OPTIN-NEXT:   (i32.and
+  ;; OPTIN-NEXT:    (i32.eq
+  ;; OPTIN-NEXT:     (local.get $x)
+  ;; OPTIN-NEXT:     (i32.const 10)
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:    (i32.eq
+  ;; OPTIN-NEXT:     (local.tee $y
+  ;; OPTIN-NEXT:      (block (result i32)
+  ;; OPTIN-NEXT:       (local.set $x
+  ;; OPTIN-NEXT:        (i32.const 20)
+  ;; OPTIN-NEXT:       )
+  ;; OPTIN-NEXT:       (call $import)
+  ;; OPTIN-NEXT:      )
+  ;; OPTIN-NEXT:     )
+  ;; OPTIN-NEXT:     (i32.const 30)
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:   )
+  ;; OPTIN-NEXT:   (then
+  ;; OPTIN-NEXT:    (drop
+  ;; OPTIN-NEXT:     (i32.const 0)
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:    (drop
+  ;; OPTIN-NEXT:     (i32.const 1)
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:    (drop
+  ;; OPTIN-NEXT:     (i32.eq
+  ;; OPTIN-NEXT:      (local.get $y)
+  ;; OPTIN-NEXT:      (i32.const 30)
+  ;; OPTIN-NEXT:     )
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:   )
+  ;; OPTIN-NEXT:  )
+  ;; OPTIN-NEXT: )
+  (func $tee-condition-nested (param $x i32) (param $y i32)
+    ;; A second set is nested inside the tee. $x initially seems like it must be
+    ;; equal to 10 in the If body, but it is set to 20 after.
+    (if
+      (i32.and
+        (i32.eq
+          (local.get $x)
+          (i32.const 10)
+        )
+        (i32.eq
+          (local.tee $y
+            (block (result i32)
+              (local.set $x
+                (i32.const 20)
+              )
+              (call $import)
+            )
+          )
+          (i32.const 30)
+        )
+      )
+      (then
+        ;; This is false: $x was 10 (if the first ANDed expression was true),
+        ;; but $x was set to 20 after.
+        (drop
+          (i32.eq
+            (local.get $x)
+            (i32.const 10)
+          )
+        )
+        ;; This is true.
+        (drop
+          (i32.eq
+            (local.get $x)
+            (i32.const 20)
+          )
+        )
+        ;; We don't infer this, even though we could: the get and later set of
+        ;; $x make us give up. TODO
+        (drop
+          (i32.eq
+            (local.get $y)
+            (i32.const 30)
+          )
+        )
+      )
+    )
+  )
+
+  ;; CHECK:      (func $tee-condition-nested-2 (type $3) (param $x i32) (param $y i32) (param $z i32)
+  ;; CHECK-NEXT:  (if
+  ;; CHECK-NEXT:   (i32.and
+  ;; CHECK-NEXT:    (i32.eq
+  ;; CHECK-NEXT:     (local.get $x)
+  ;; CHECK-NEXT:     (i32.const 10)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:    (i32.eq
+  ;; CHECK-NEXT:     (local.tee $y
+  ;; CHECK-NEXT:      (block (result i32)
+  ;; CHECK-NEXT:       (local.set $z
+  ;; CHECK-NEXT:        (i32.const 20)
+  ;; CHECK-NEXT:       )
+  ;; CHECK-NEXT:       (call $import)
+  ;; CHECK-NEXT:      )
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:     (i32.const 30)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (then
+  ;; CHECK-NEXT:    (drop
+  ;; CHECK-NEXT:     (i32.const 1)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:    (drop
+  ;; CHECK-NEXT:     (i32.const 1)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:    (drop
+  ;; CHECK-NEXT:     (i32.const 1)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  ;; OPTIN:      (func $tee-condition-nested-2 (type $3) (param $x i32) (param $y i32) (param $z i32)
+  ;; OPTIN-NEXT:  (if
+  ;; OPTIN-NEXT:   (i32.and
+  ;; OPTIN-NEXT:    (i32.eq
+  ;; OPTIN-NEXT:     (local.get $x)
+  ;; OPTIN-NEXT:     (i32.const 10)
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:    (i32.eq
+  ;; OPTIN-NEXT:     (local.tee $y
+  ;; OPTIN-NEXT:      (block (result i32)
+  ;; OPTIN-NEXT:       (local.set $z
+  ;; OPTIN-NEXT:        (i32.const 20)
+  ;; OPTIN-NEXT:       )
+  ;; OPTIN-NEXT:       (call $import)
+  ;; OPTIN-NEXT:      )
+  ;; OPTIN-NEXT:     )
+  ;; OPTIN-NEXT:     (i32.const 30)
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:   )
+  ;; OPTIN-NEXT:   (then
+  ;; OPTIN-NEXT:    (drop
+  ;; OPTIN-NEXT:     (i32.const 1)
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:    (drop
+  ;; OPTIN-NEXT:     (i32.const 1)
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:    (drop
+  ;; OPTIN-NEXT:     (i32.const 1)
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:   )
+  ;; OPTIN-NEXT:  )
+  ;; OPTIN-NEXT: )
+  (func $tee-condition-nested-2 (param $x i32) (param $y i32) (param $z i32)
+    ;; As above, but the second set is of another local. Without any conflict,
+    ;; we can infer more.
+    (if
+      (i32.and
+        (i32.eq
+          (local.get $x)
+          (i32.const 10)
+        )
+        (i32.eq
+          (local.tee $y
+            (block (result i32)
+              (local.set $z      ;; this changed
+                (i32.const 20)
+              )
+              (call $import)
+            )
+          )
+          (i32.const 30)
+        )
+      )
+      (then
+        ;; These are all true.
+        (drop
+          (i32.eq
+            (local.get $x)
+            (i32.const 10)
+          )
+        )
+        (drop
+          (i32.eq
+            (local.get $y)
+            (i32.const 30)
+          )
+        )
+        (drop
+          (i32.eq
+            (local.get $z)
+            (i32.const 20)
+          )
+        )
+      )
+    )
+  )
+
+  ;; CHECK:      (func $tee-condition-nested-get (type $2) (param $x i32) (param $y i32)
+  ;; CHECK-NEXT:  (if
+  ;; CHECK-NEXT:   (i32.and
+  ;; CHECK-NEXT:    (i32.eq
+  ;; CHECK-NEXT:     (local.get $x)
+  ;; CHECK-NEXT:     (i32.const 10)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:    (i32.eq
+  ;; CHECK-NEXT:     (local.tee $y
+  ;; CHECK-NEXT:      (block (result i32)
+  ;; CHECK-NEXT:       (drop
+  ;; CHECK-NEXT:        (local.get $x)
+  ;; CHECK-NEXT:       )
+  ;; CHECK-NEXT:       (call $import)
+  ;; CHECK-NEXT:      )
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:     (i32.const 30)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (then
+  ;; CHECK-NEXT:    (drop
+  ;; CHECK-NEXT:     (i32.const 1)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:    (drop
+  ;; CHECK-NEXT:     (i32.const 1)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  ;; OPTIN:      (func $tee-condition-nested-get (type $2) (param $x i32) (param $y i32)
+  ;; OPTIN-NEXT:  (if
+  ;; OPTIN-NEXT:   (i32.and
+  ;; OPTIN-NEXT:    (i32.eq
+  ;; OPTIN-NEXT:     (local.get $x)
+  ;; OPTIN-NEXT:     (i32.const 10)
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:    (i32.eq
+  ;; OPTIN-NEXT:     (local.tee $y
+  ;; OPTIN-NEXT:      (block (result i32)
+  ;; OPTIN-NEXT:       (drop
+  ;; OPTIN-NEXT:        (local.get $x)
+  ;; OPTIN-NEXT:       )
+  ;; OPTIN-NEXT:       (call $import)
+  ;; OPTIN-NEXT:      )
+  ;; OPTIN-NEXT:     )
+  ;; OPTIN-NEXT:     (i32.const 30)
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:   )
+  ;; OPTIN-NEXT:   (then
+  ;; OPTIN-NEXT:    (drop
+  ;; OPTIN-NEXT:     (i32.const 1)
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:    (drop
+  ;; OPTIN-NEXT:     (i32.const 1)
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:   )
+  ;; OPTIN-NEXT:  )
+  ;; OPTIN-NEXT: )
+  (func $tee-condition-nested-get (param $x i32) (param $y i32)
+    ;; As $tee-condition-nested, but rather than a nested *set*, a get. A get
+    ;; is not a problem for us.
+    (if
+      (i32.and
+        (i32.eq
+          (local.get $x)
+          (i32.const 10)
+        )
+        (i32.eq
+          (local.tee $y
+            (block (result i32)
+              (drop
+                (local.get $x)   ;; this changed.
+              )
+              (call $import)
+            )
+          )
+          (i32.const 30)
+        )
+      )
+      (then
+        ;; These are all true.
+        (drop
+          (i32.eq
+            (local.get $x)
+            (i32.const 10)
+          )
+        )
+        (drop
+          (i32.eq
+            (local.get $y)
+            (i32.const 30)
+          )
+        )
+      )
+    )
+  )
+
+  ;; CHECK:      (func $tee-trample-simple (type $0) (param $x i32)
+  ;; CHECK-NEXT:  (if
+  ;; CHECK-NEXT:   (i32.and
+  ;; CHECK-NEXT:    (i32.eqz
+  ;; CHECK-NEXT:     (local.get $x)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:    (local.tee $x
+  ;; CHECK-NEXT:     (call $import)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (then
+  ;; CHECK-NEXT:    (drop
+  ;; CHECK-NEXT:     (i32.eqz
+  ;; CHECK-NEXT:      (local.get $x)
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  ;; OPTIN:      (func $tee-trample-simple (type $0) (param $x i32)
+  ;; OPTIN-NEXT:  (if
+  ;; OPTIN-NEXT:   (i32.and
+  ;; OPTIN-NEXT:    (i32.eqz
+  ;; OPTIN-NEXT:     (local.get $x)
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:    (local.tee $x
+  ;; OPTIN-NEXT:     (call $import)
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:   )
+  ;; OPTIN-NEXT:   (then
+  ;; OPTIN-NEXT:    (drop
+  ;; OPTIN-NEXT:     (i32.eqz
+  ;; OPTIN-NEXT:      (local.get $x)
+  ;; OPTIN-NEXT:     )
+  ;; OPTIN-NEXT:    )
+  ;; OPTIN-NEXT:   )
+  ;; OPTIN-NEXT:  )
+  ;; OPTIN-NEXT: )
+  (func $tee-trample-simple (param $x i32)
+    (if
+      (i32.and
+        ;; $x == 0
+        (i32.eqz
+          (local.get $x)
+        )
+        ;; But then trample $x with an unknown value.
+        (local.tee $x
+          (call $import)
+        )
+      )
+      (then
+        ;; $x may not be 0 here, as it was trampled, so we infer nothing.
+        (drop
+          (i32.eqz
+            (local.get $x)
+          )
+        )
+      )
+    )
+  )
+)
+
diff --git a/test/lit/passes/global-effects-suspends.wast b/test/lit/passes/global-effects-suspends.wast
new file mode 100644
index 00000000000..00c53ee09d2
--- /dev/null
+++ b/test/lit/passes/global-effects-suspends.wast
@@ -0,0 +1,340 @@
+;; NOTE: Assertions have been generated by update_lit_checks.py and should not be edited.
+;; Test that global effects properly track suspension across functions,
+;; call chains, cycles, and indirect calls.
+
+;; RUN: foreach %s %t wasm-opt -all --generate-global-effects --vacuum -S -o - | filecheck %s --check-prefix VACUUM
+;; RUN: foreach %s %t wasm-opt -all --generate-global-effects --closed-world --vacuum -S -o - | filecheck %s --check-prefix CLOSED-VACUUM
+;; RUN: foreach %s %t wasm-opt -all --generate-global-effects --simplify-locals -S -o - | filecheck %s --check-prefix SIMPLIFY
+
+(module
+  (memory 1 1)
+  ;; VACUUM:      (tag $tag (type $0))
+  ;; CLOSED-VACUUM:      (tag $tag (type $0))
+  ;; SIMPLIFY:      (tag $tag (type $0))
+  (tag $tag)
+
+  ;; VACUUM:      (func $pure (type $0)
+  ;; VACUUM-NEXT:  (nop)
+  ;; VACUUM-NEXT: )
+  ;; CLOSED-VACUUM:      (func $pure (type $0)
+  ;; CLOSED-VACUUM-NEXT:  (nop)
+  ;; CLOSED-VACUUM-NEXT: )
+  ;; SIMPLIFY:      (func $pure (type $0)
+  ;; SIMPLIFY-NEXT:  (nop)
+  ;; SIMPLIFY-NEXT: )
+  (func $pure
+    (nop)
+  )
+
+  ;; VACUUM:      (func $caller-of-pure (type $0)
+  ;; VACUUM-NEXT:  (nop)
+  ;; VACUUM-NEXT: )
+  ;; CLOSED-VACUUM:      (func $caller-of-pure (type $0)
+  ;; CLOSED-VACUUM-NEXT:  (nop)
+  ;; CLOSED-VACUUM-NEXT: )
+  ;; SIMPLIFY:      (func $caller-of-pure (type $0)
+  ;; SIMPLIFY-NEXT:  (call $pure)
+  ;; SIMPLIFY-NEXT: )
+  (func $caller-of-pure
+    (call $pure)
+  )
+
+  ;; VACUUM:      (func $suspending (type $0)
+  ;; VACUUM-NEXT:  (suspend $tag)
+  ;; VACUUM-NEXT: )
+  ;; CLOSED-VACUUM:      (func $suspending (type $0)
+  ;; CLOSED-VACUUM-NEXT:  (suspend $tag)
+  ;; CLOSED-VACUUM-NEXT: )
+  ;; SIMPLIFY:      (func $suspending (type $0)
+  ;; SIMPLIFY-NEXT:  (suspend $tag)
+  ;; SIMPLIFY-NEXT: )
+  (func $suspending
+    (suspend $tag)
+  )
+
+  ;; VACUUM:      (func $caller-of-suspending (type $0)
+  ;; VACUUM-NEXT:  (call $suspending)
+  ;; VACUUM-NEXT: )
+  ;; CLOSED-VACUUM:      (func $caller-of-suspending (type $0)
+  ;; CLOSED-VACUUM-NEXT:  (call $suspending)
+  ;; CLOSED-VACUUM-NEXT: )
+  ;; SIMPLIFY:      (func $caller-of-suspending (type $0)
+  ;; SIMPLIFY-NEXT:  (call $suspending)
+  ;; SIMPLIFY-NEXT: )
+  (func $caller-of-suspending
+    (call $suspending)
+  )
+
+  ;; VACUUM:      (func $transitive-caller-of-suspending (type $0)
+  ;; VACUUM-NEXT:  (call $caller-of-suspending)
+  ;; VACUUM-NEXT: )
+  ;; CLOSED-VACUUM:      (func $transitive-caller-of-suspending (type $0)
+  ;; CLOSED-VACUUM-NEXT:  (call $caller-of-suspending)
+  ;; CLOSED-VACUUM-NEXT: )
+  ;; SIMPLIFY:      (func $transitive-caller-of-suspending (type $0)
+  ;; SIMPLIFY-NEXT:  (call $caller-of-suspending)
+  ;; SIMPLIFY-NEXT: )
+  (func $transitive-caller-of-suspending
+    (call $caller-of-suspending)
+  )
+
+  ;; Cycles
+  ;; VACUUM:      (func $cycle-suspend-a (type $0)
+  ;; VACUUM-NEXT:  (call $cycle-suspend-b)
+  ;; VACUUM-NEXT: )
+  ;; CLOSED-VACUUM:      (func $cycle-suspend-a (type $0)
+  ;; CLOSED-VACUUM-NEXT:  (call $cycle-suspend-b)
+  ;; CLOSED-VACUUM-NEXT: )
+  ;; SIMPLIFY:      (func $cycle-suspend-a (type $0)
+  ;; SIMPLIFY-NEXT:  (call $cycle-suspend-b)
+  ;; SIMPLIFY-NEXT: )
+  (func $cycle-suspend-a
+    (call $cycle-suspend-b)
+  )
+
+  ;; VACUUM:      (func $cycle-suspend-b (type $0)
+  ;; VACUUM-NEXT:  (call $cycle-suspend-a)
+  ;; VACUUM-NEXT:  (call $suspending)
+  ;; VACUUM-NEXT: )
+  ;; CLOSED-VACUUM:      (func $cycle-suspend-b (type $0)
+  ;; CLOSED-VACUUM-NEXT:  (call $cycle-suspend-a)
+  ;; CLOSED-VACUUM-NEXT:  (call $suspending)
+  ;; CLOSED-VACUUM-NEXT: )
+  ;; SIMPLIFY:      (func $cycle-suspend-b (type $0)
+  ;; SIMPLIFY-NEXT:  (call $cycle-suspend-a)
+  ;; SIMPLIFY-NEXT:  (call $suspending)
+  ;; SIMPLIFY-NEXT: )
+  (func $cycle-suspend-b
+    (call $cycle-suspend-a)
+    (call $suspending)
+  )
+
+  ;; Vacuum tests: pure calls should be eliminated, suspending calls preserved.
+  ;; VACUUM:      (func $test-vacuum (type $0)
+  ;; VACUUM-NEXT:  (call $suspending)
+  ;; VACUUM-NEXT:  (call $caller-of-suspending)
+  ;; VACUUM-NEXT:  (call $transitive-caller-of-suspending)
+  ;; VACUUM-NEXT:  (call $cycle-suspend-a)
+  ;; VACUUM-NEXT: )
+  ;; CLOSED-VACUUM:      (func $test-vacuum (type $0)
+  ;; CLOSED-VACUUM-NEXT:  (call $suspending)
+  ;; CLOSED-VACUUM-NEXT:  (call $caller-of-suspending)
+  ;; CLOSED-VACUUM-NEXT:  (call $transitive-caller-of-suspending)
+  ;; CLOSED-VACUUM-NEXT:  (call $cycle-suspend-a)
+  ;; CLOSED-VACUUM-NEXT: )
+  ;; SIMPLIFY:      (func $test-vacuum (type $0)
+  ;; SIMPLIFY-NEXT:  (call $pure)
+  ;; SIMPLIFY-NEXT:  (call $caller-of-pure)
+  ;; SIMPLIFY-NEXT:  (call $suspending)
+  ;; SIMPLIFY-NEXT:  (call $caller-of-suspending)
+  ;; SIMPLIFY-NEXT:  (call $transitive-caller-of-suspending)
+  ;; SIMPLIFY-NEXT:  (call $cycle-suspend-a)
+  ;; SIMPLIFY-NEXT: )
+  (func $test-vacuum
+    ;; Pure calls eliminated:
+    (call $pure)
+    (call $caller-of-pure)
+
+    ;; Direct, transitive, and cyclic calls to suspend preserved:
+    (call $suspending)
+    (call $caller-of-suspending)
+    (call $transitive-caller-of-suspending)
+    (call $cycle-suspend-a)
+  )
+
+  ;; Simplify-locals test: memory access cannot be reordered or eliminated
+  ;; across a call to a function that directly or transitively suspends.
+  ;; VACUUM:      (func $test-simplify-memory (type $1) (result i32)
+  ;; VACUUM-NEXT:  (local $x i32)
+  ;; VACUUM-NEXT:  (local.set $x
+  ;; VACUUM-NEXT:   (i32.load
+  ;; VACUUM-NEXT:    (i32.const 0)
+  ;; VACUUM-NEXT:   )
+  ;; VACUUM-NEXT:  )
+  ;; VACUUM-NEXT:  (call $caller-of-suspending)
+  ;; VACUUM-NEXT:  (local.get $x)
+  ;; VACUUM-NEXT: )
+  ;; CLOSED-VACUUM:      (func $test-simplify-memory (type $1) (result i32)
+  ;; CLOSED-VACUUM-NEXT:  (local $x i32)
+  ;; CLOSED-VACUUM-NEXT:  (local.set $x
+  ;; CLOSED-VACUUM-NEXT:   (i32.load
+  ;; CLOSED-VACUUM-NEXT:    (i32.const 0)
+  ;; CLOSED-VACUUM-NEXT:   )
+  ;; CLOSED-VACUUM-NEXT:  )
+  ;; CLOSED-VACUUM-NEXT:  (call $caller-of-suspending)
+  ;; CLOSED-VACUUM-NEXT:  (local.get $x)
+  ;; CLOSED-VACUUM-NEXT: )
+  ;; SIMPLIFY:      (func $test-simplify-memory (type $1) (result i32)
+  ;; SIMPLIFY-NEXT:  (local $x i32)
+  ;; SIMPLIFY-NEXT:  (local.set $x
+  ;; SIMPLIFY-NEXT:   (i32.load
+  ;; SIMPLIFY-NEXT:    (i32.const 0)
+  ;; SIMPLIFY-NEXT:   )
+  ;; SIMPLIFY-NEXT:  )
+  ;; SIMPLIFY-NEXT:  (call $caller-of-suspending)
+  ;; SIMPLIFY-NEXT:  (local.get $x)
+  ;; SIMPLIFY-NEXT: )
+  (func $test-simplify-memory (result i32)
+    ;; Simplify-locals cannot move the load across a possibly-suspending call
+    ;; because the handler might modify memory before resuming.
+    (local $x i32)
+    (local.set $x (i32.load (i32.const 0)))
+    (call $caller-of-suspending)
+    (local.get $x)
+  )
+
+  ;; VACUUM:      (func $test-simplify-pure (type $1) (result i32)
+  ;; VACUUM-NEXT:  (local $x i32)
+  ;; VACUUM-NEXT:  (local.set $x
+  ;; VACUUM-NEXT:   (i32.load
+  ;; VACUUM-NEXT:    (i32.const 0)
+  ;; VACUUM-NEXT:   )
+  ;; VACUUM-NEXT:  )
+  ;; VACUUM-NEXT:  (local.get $x)
+  ;; VACUUM-NEXT: )
+  ;; CLOSED-VACUUM:      (func $test-simplify-pure (type $1) (result i32)
+  ;; CLOSED-VACUUM-NEXT:  (local $x i32)
+  ;; CLOSED-VACUUM-NEXT:  (local.set $x
+  ;; CLOSED-VACUUM-NEXT:   (i32.load
+  ;; CLOSED-VACUUM-NEXT:    (i32.const 0)
+  ;; CLOSED-VACUUM-NEXT:   )
+  ;; CLOSED-VACUUM-NEXT:  )
+  ;; CLOSED-VACUUM-NEXT:  (local.get $x)
+  ;; CLOSED-VACUUM-NEXT: )
+  ;; SIMPLIFY:      (func $test-simplify-pure (type $1) (result i32)
+  ;; SIMPLIFY-NEXT:  (local $x i32)
+  ;; SIMPLIFY-NEXT:  (nop)
+  ;; SIMPLIFY-NEXT:  (call $caller-of-pure)
+  ;; SIMPLIFY-NEXT:  (i32.load
+  ;; SIMPLIFY-NEXT:   (i32.const 0)
+  ;; SIMPLIFY-NEXT:  )
+  ;; SIMPLIFY-NEXT: )
+  (func $test-simplify-pure (result i32)
+    ;; When global effects tells us the callee will never suspend (or have other
+    ;; effects), simplify-locals can safely move a load across it.
+    (local $x i32)
+    (local.set $x (i32.load (i32.const 0)))
+    (call $caller-of-pure)
+    (local.get $x)
+  )
+)
+
+(module
+  ;; VACUUM:      (type $sig-suspending (func (param i32)))
+
+  ;; VACUUM:      (type $sig-pure (func (param i64)))
+
+  ;; VACUUM:      (tag $tag (type $2))
+  ;; CLOSED-VACUUM:      (type $sig-suspending (func (param i32)))
+
+  ;; CLOSED-VACUUM:      (type $sig-pure (func (param i64)))
+
+  ;; CLOSED-VACUUM:      (tag $tag (type $2))
+  ;; SIMPLIFY:      (type $sig-suspending (func (param i32)))
+
+  ;; SIMPLIFY:      (type $sig-pure (func (param i64)))
+
+  ;; SIMPLIFY:      (tag $tag (type $2))
+  (tag $tag)
+  (type $sig-suspending (func (param i32)))
+  (type $sig-pure (func (param i64)))
+
+  (table 1 1 funcref)
+
+  ;; VACUUM:      (func $target-suspend (type $sig-suspending) (param $0 i32)
+  ;; VACUUM-NEXT:  (suspend $tag)
+  ;; VACUUM-NEXT: )
+  ;; CLOSED-VACUUM:      (func $target-suspend (type $sig-suspending) (param $0 i32)
+  ;; CLOSED-VACUUM-NEXT:  (suspend $tag)
+  ;; CLOSED-VACUUM-NEXT: )
+  ;; SIMPLIFY:      (func $target-suspend (type $sig-suspending) (param $0 i32)
+  ;; SIMPLIFY-NEXT:  (suspend $tag)
+  ;; SIMPLIFY-NEXT: )
+  (func $target-suspend (export "target-suspend") (type $sig-suspending) (param i32)
+    (suspend $tag)
+  )
+
+  ;; VACUUM:      (func $target-pure (type $sig-pure) (param $0 i64)
+  ;; VACUUM-NEXT:  (nop)
+  ;; VACUUM-NEXT: )
+  ;; CLOSED-VACUUM:      (func $target-pure (type $sig-pure) (param $0 i64)
+  ;; CLOSED-VACUUM-NEXT:  (nop)
+  ;; CLOSED-VACUUM-NEXT: )
+  ;; SIMPLIFY:      (func $target-pure (type $sig-pure) (param $0 i64)
+  ;; SIMPLIFY-NEXT:  (nop)
+  ;; SIMPLIFY-NEXT: )
+  (func $target-pure (export "target-pure") (type $sig-pure) (param i64)
+    (nop)
+  )
+
+  ;; VACUUM:      (func $test-indirect-suspend (type $3) (param $ref (ref $sig-suspending))
+  ;; VACUUM-NEXT:  (call_ref $sig-suspending
+  ;; VACUUM-NEXT:   (i32.const 0)
+  ;; VACUUM-NEXT:   (local.get $ref)
+  ;; VACUUM-NEXT:  )
+  ;; VACUUM-NEXT: )
+  ;; CLOSED-VACUUM:      (func $test-indirect-suspend (type $3) (param $ref (ref $sig-suspending))
+  ;; CLOSED-VACUUM-NEXT:  (call_ref $sig-suspending
+  ;; CLOSED-VACUUM-NEXT:   (i32.const 0)
+  ;; CLOSED-VACUUM-NEXT:   (local.get $ref)
+  ;; CLOSED-VACUUM-NEXT:  )
+  ;; CLOSED-VACUUM-NEXT: )
+  ;; SIMPLIFY:      (func $test-indirect-suspend (type $3) (param $ref (ref $sig-suspending))
+  ;; SIMPLIFY-NEXT:  (call_ref $sig-suspending
+  ;; SIMPLIFY-NEXT:   (i32.const 0)
+  ;; SIMPLIFY-NEXT:   (local.get $ref)
+  ;; SIMPLIFY-NEXT:  )
+  ;; SIMPLIFY-NEXT: )
+  (func $test-indirect-suspend (param $ref (ref $sig-suspending))
+    ;; This has the suspend effect, so it cannot be vacuumed away.
+    (call_ref $sig-suspending (i32.const 0) (local.get $ref))
+  )
+
+  ;; VACUUM:      (func $test-indirect-pure (type $4) (param $ref (ref $sig-pure))
+  ;; VACUUM-NEXT:  (call_ref $sig-pure
+  ;; VACUUM-NEXT:   (i64.const 0)
+  ;; VACUUM-NEXT:   (local.get $ref)
+  ;; VACUUM-NEXT:  )
+  ;; VACUUM-NEXT: )
+  ;; CLOSED-VACUUM:      (func $test-indirect-pure (type $4) (param $ref (ref $sig-pure))
+  ;; CLOSED-VACUUM-NEXT:  (nop)
+  ;; CLOSED-VACUUM-NEXT: )
+  ;; SIMPLIFY:      (func $test-indirect-pure (type $4) (param $ref (ref $sig-pure))
+  ;; SIMPLIFY-NEXT:  (call_ref $sig-pure
+  ;; SIMPLIFY-NEXT:   (i64.const 0)
+  ;; SIMPLIFY-NEXT:   (local.get $ref)
+  ;; SIMPLIFY-NEXT:  )
+  ;; SIMPLIFY-NEXT: )
+  (func $test-indirect-pure (param $ref (ref $sig-pure))
+    ;; With a closed world, global effects tells us that functions of this type
+    ;; never suspend (or have other side effects), so we can vacuum this away.
+    (call_ref $sig-pure (i64.const 0) (local.get $ref))
+  )
+
+  ;; VACUUM:      (func $test-vacuum-indirect (type $5) (param $ref1 (ref $sig-suspending)) (param $ref2 (ref $sig-pure))
+  ;; VACUUM-NEXT:  (call $test-indirect-pure
+  ;; VACUUM-NEXT:   (local.get $ref2)
+  ;; VACUUM-NEXT:  )
+  ;; VACUUM-NEXT:  (call $test-indirect-suspend
+  ;; VACUUM-NEXT:   (local.get $ref1)
+  ;; VACUUM-NEXT:  )
+  ;; VACUUM-NEXT: )
+  ;; CLOSED-VACUUM:      (func $test-vacuum-indirect (type $5) (param $ref1 (ref $sig-suspending)) (param $ref2 (ref $sig-pure))
+  ;; CLOSED-VACUUM-NEXT:  (call $test-indirect-suspend
+  ;; CLOSED-VACUUM-NEXT:   (local.get $ref1)
+  ;; CLOSED-VACUUM-NEXT:  )
+  ;; CLOSED-VACUUM-NEXT: )
+  ;; SIMPLIFY:      (func $test-vacuum-indirect (type $5) (param $ref1 (ref $sig-suspending)) (param $ref2 (ref $sig-pure))
+  ;; SIMPLIFY-NEXT:  (call $test-indirect-pure
+  ;; SIMPLIFY-NEXT:   (local.get $ref2)
+  ;; SIMPLIFY-NEXT:  )
+  ;; SIMPLIFY-NEXT:  (call $test-indirect-suspend
+  ;; SIMPLIFY-NEXT:   (local.get $ref1)
+  ;; SIMPLIFY-NEXT:  )
+  ;; SIMPLIFY-NEXT: )
+  (func $test-vacuum-indirect (param $ref1 (ref $sig-suspending)) (param $ref2 (ref $sig-pure))
+    ;; The pure indirect call can be eliminated in closed-world, but not the suspending one.
+    (call $test-indirect-pure (local.get $ref2))
+    (call $test-indirect-suspend (local.get $ref1))
+  )
+)
diff --git a/test/lit/passes/gto-jsinterop.wast b/test/lit/passes/gto-jsinterop.wast
index 6376b7553f3..4a2e24d8073 100644
--- a/test/lit/passes/gto-jsinterop.wast
+++ b/test/lit/passes/gto-jsinterop.wast
@@ -685,3 +685,1071 @@
     (local (ref null $sub))
   )
 )
+
+(module
+  ;; Field 0 is mutable externref. It can become immutable, but doing so would
+  ;; expose it as a prototype. An immutable i8 placeholder is prepended.
+  (rec
+    ;; CHECK:      (rec
+    ;; CHECK-NEXT:  (type $struct (descriptor $desc) (struct))
+    (type $struct (descriptor $desc) (struct))
+    ;; CHECK:       (type $desc (describes $struct) (struct (field i8) (field externref)))
+    (type $desc (describes $struct) (struct (field (mut externref))))
+  )
+
+  ;; CHECK:       (type $2 (func (param (ref $desc))))
+
+  ;; CHECK:      (type $3 (func (result structref)))
+
+  ;; CHECK:      (export "export" (func $test))
+  (export "export" (func $test))
+
+  ;; CHECK:      (func $test (type $3) (result structref)
+  ;; CHECK-NEXT:  (struct.new_default_desc $struct
+  ;; CHECK-NEXT:   (struct.new $desc
+  ;; CHECK-NEXT:    (i32.const 0)
+  ;; CHECK-NEXT:    (extern.convert_any
+  ;; CHECK-NEXT:     (struct.new_default $desc)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $test (result structref)
+    (struct.new_desc $struct
+      (struct.new $desc
+        (extern.convert_any
+          (struct.new_default $desc)
+        )
+      )
+    )
+  )
+
+  ;; CHECK:      (func $get (type $2) (param $d (ref $desc))
+  ;; CHECK-NEXT:  (drop
+  ;; CHECK-NEXT:   (struct.get $desc 1
+  ;; CHECK-NEXT:    (local.get $d)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $get (param $d (ref $desc))
+    (drop
+      (struct.get $desc 0
+        (local.get $d)
+      )
+    )
+  )
+)
+
+(module
+  ;; Field 0 is mutable non-nullable externref. It can become immutable, but
+  ;; doing so would expose it as a prototype. An immutable i8 placeholder is
+  ;; prepended.
+  (rec
+    ;; CHECK:      (rec
+    ;; CHECK-NEXT:  (type $struct (descriptor $desc) (struct))
+    (type $struct (descriptor $desc) (struct))
+    ;; CHECK:       (type $desc (describes $struct) (struct (field i8) (field (ref extern))))
+    (type $desc (describes $struct) (struct (field (mut (ref extern)))))
+  )
+
+  ;; CHECK:       (type $2 (func (param (ref $desc))))
+
+  ;; CHECK:      (type $3 (func (param (ref extern)) (result structref)))
+
+  ;; CHECK:      (export "export" (func $test))
+  (export "export" (func $test))
+  ;; CHECK:      (func $test (type $3) (param $e (ref extern)) (result structref)
+  ;; CHECK-NEXT:  (struct.new_default_desc $struct
+  ;; CHECK-NEXT:   (struct.new $desc
+  ;; CHECK-NEXT:    (i32.const 0)
+  ;; CHECK-NEXT:    (local.get $e)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $test (param $e (ref extern)) (result structref)
+    (struct.new_desc $struct
+      (struct.new $desc
+        (local.get $e)
+      )
+    )
+  )
+
+  ;; CHECK:      (func $get (type $2) (param $d (ref $desc))
+  ;; CHECK-NEXT:  (drop
+  ;; CHECK-NEXT:   (struct.get $desc 1
+  ;; CHECK-NEXT:    (local.get $d)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $get (param $d (ref $desc))
+    (drop
+      (struct.get $desc 0
+        (local.get $d)
+      )
+    )
+  )
+)
+
+(module
+  ;; Field 0 is unused and can be removed. Field 1 is immutable externref.
+  ;; Removing field 0 would shift field 1 into index 0 and expose it as a
+  ;; prototype. An immutable i8 placeholder is inserted at index 0.
+  (rec
+    ;; CHECK:      (rec
+    ;; CHECK-NEXT:  (type $struct (descriptor $desc) (struct))
+    (type $struct (descriptor $desc) (struct))
+    ;; CHECK:       (type $desc (describes $struct) (struct (field i8) (field externref)))
+    (type $desc (describes $struct) (struct (field i32) (field externref)))
+  )
+
+  ;; CHECK:       (type $2 (func (param (ref $desc))))
+
+  ;; CHECK:      (type $3 (func (result structref)))
+
+  ;; CHECK:      (export "export" (func $test))
+  (export "export" (func $test))
+  ;; CHECK:      (func $test (type $3) (result structref)
+  ;; CHECK-NEXT:  (struct.new_default_desc $struct
+  ;; CHECK-NEXT:   (struct.new $desc
+  ;; CHECK-NEXT:    (i32.const 0)
+  ;; CHECK-NEXT:    (extern.convert_any
+  ;; CHECK-NEXT:     (struct.new_default $desc)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $test (result structref)
+    (struct.new_desc $struct
+      (struct.new $desc
+        (i32.const 42)
+        (extern.convert_any
+          (struct.new_default $desc)
+        )
+      )
+    )
+  )
+
+  ;; CHECK:      (func $get (type $2) (param $d (ref $desc))
+  ;; CHECK-NEXT:  (drop
+  ;; CHECK-NEXT:   (struct.get $desc 1
+  ;; CHECK-NEXT:    (local.get $d)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $get (param $d (ref $desc))
+    (drop
+      (struct.get $desc 1
+        (local.get $d)
+      )
+    )
+  )
+)
+
+(module
+  ;; Field 0 is unused in $super-desc and removed. Field 1 is an immutable
+  ;; externref. $sub-desc still uses field 0. $super-desc reorders field 1 to
+  ;; index 0 to remove field 0 from the end. Because field 0 is now externref,
+  ;; a placeholder is inserted.
+  (rec
+    ;; CHECK:      (rec
+    ;; CHECK-NEXT:  (type $super (sub (descriptor $super-desc) (struct)))
+    (type $super (sub (descriptor $super-desc) (struct)))
+    ;; CHECK:       (type $super-desc (sub (describes $super) (struct (field i8) (field externref))))
+    (type $super-desc (sub (describes $super) (struct (field i32) (field externref))))
+  )
+  (rec
+    ;; CHECK:       (type $sub (sub $super (descriptor $sub-desc) (struct)))
+    (type $sub (sub $super (descriptor $sub-desc) (struct)))
+    ;; CHECK:       (type $sub-desc (sub $super-desc (describes $sub) (struct (field i8) (field externref) (field i32))))
+    (type $sub-desc (sub $super-desc (describes $sub) (struct (field i32) (field externref))))
+  )
+
+  ;; CHECK:       (type $4 (func (param (ref $super-desc))))
+
+  ;; CHECK:       (type $5 (func (param (ref $sub-desc))))
+
+  ;; CHECK:      (type $6 (func (result structref)))
+
+  ;; CHECK:      (export "export" (func $test))
+  (export "export" (func $test))
+  ;; CHECK:      (func $test (type $6) (result structref)
+  ;; CHECK-NEXT:  (struct.new_default_desc $super
+  ;; CHECK-NEXT:   (struct.new $super-desc
+  ;; CHECK-NEXT:    (i32.const 0)
+  ;; CHECK-NEXT:    (extern.convert_any
+  ;; CHECK-NEXT:     (struct.new_default $super-desc)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $test (result structref)
+    (struct.new_desc $super
+      (struct.new $super-desc
+        (i32.const 42)
+        (extern.convert_any
+          (struct.new_default $super-desc)
+        )
+      )
+    )
+  )
+
+  ;; CHECK:      (func $use-super (type $4) (param $d (ref $super-desc))
+  ;; CHECK-NEXT:  (drop
+  ;; CHECK-NEXT:   (struct.get $super-desc 1
+  ;; CHECK-NEXT:    (local.get $d)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $use-super (param $d (ref $super-desc))
+    (drop
+      (struct.get $super-desc 1
+        (local.get $d)
+      )
+    )
+  )
+
+  ;; CHECK:      (func $use-sub (type $5) (param $d (ref $sub-desc))
+  ;; CHECK-NEXT:  (drop
+  ;; CHECK-NEXT:   (struct.get $sub-desc 2
+  ;; CHECK-NEXT:    (local.get $d)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT:  (drop
+  ;; CHECK-NEXT:   (struct.get $sub-desc 1
+  ;; CHECK-NEXT:    (local.get $d)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $use-sub (param $d (ref $sub-desc))
+    (drop
+      (struct.get $sub-desc 0
+        (local.get $d)
+      )
+    )
+    (drop
+      (struct.get $sub-desc 1
+        (local.get $d)
+      )
+    )
+  )
+)
+
+(module
+  ;; The supertype descriptor is empty. The subtype descriptor has a mutable
+  ;; externref field. The subtype descriptor gets an i8 placeholder while
+  ;; continuing to validly subtype the supertype descriptor.
+  (rec
+    ;; CHECK:      (rec
+    ;; CHECK-NEXT:  (type $super (sub (descriptor $super-desc) (struct)))
+    (type $super (sub (descriptor $super-desc) (struct)))
+    ;; CHECK:       (type $super-desc (sub (describes $super) (struct)))
+    (type $super-desc (sub (describes $super) (struct)))
+  )
+  (rec
+    ;; CHECK:       (type $sub (sub $super (descriptor $sub-desc) (struct)))
+    (type $sub (sub $super (descriptor $sub-desc) (struct)))
+    ;; CHECK:       (type $sub-desc (sub $super-desc (describes $sub) (struct (field i8) (field externref))))
+    (type $sub-desc (sub $super-desc (describes $sub) (struct (field (mut externref)))))
+  )
+
+
+  ;; CHECK:       (type $4 (func (param (ref $sub-desc))))
+
+  ;; CHECK:      (type $5 (func (result structref)))
+
+  ;; CHECK:      (export "export" (func $test))
+  (export "export" (func $test))
+
+  ;; CHECK:      (func $test (type $5) (result structref)
+  ;; CHECK-NEXT:  (struct.new_default_desc $sub
+  ;; CHECK-NEXT:   (struct.new $sub-desc
+  ;; CHECK-NEXT:    (i32.const 0)
+  ;; CHECK-NEXT:    (ref.null noextern)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $test (result structref)
+    (struct.new_desc $sub
+      (struct.new $sub-desc
+        (ref.null extern)
+      )
+    )
+  )
+
+  ;; CHECK:      (func $use (type $4) (param $d (ref $sub-desc))
+  ;; CHECK-NEXT:  (drop
+  ;; CHECK-NEXT:   (struct.get $sub-desc 1
+  ;; CHECK-NEXT:    (local.get $d)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $use (param $d (ref $sub-desc))
+    (drop
+      (struct.get $sub-desc 0
+        (local.get $d)
+      )
+    )
+  )
+)
+
+(module
+  ;; A supertype gets a placeholder, so its non-exposed subtype also gets a
+  ;; placeholder.
+  (rec
+    ;; CHECK:      (rec
+    ;; CHECK-NEXT:  (type $super (sub (descriptor $super-desc) (struct)))
+    (type $super (sub (descriptor $super-desc) (struct)))
+    ;; CHECK:       (type $super-desc (sub (describes $super) (struct (field i8) (field externref))))
+    (type $super-desc (sub (describes $super) (struct (field (mut externref)))))
+  )
+  (rec
+    ;; CHECK:       (type $sub (sub $super (descriptor $sub-desc) (struct)))
+    (type $sub (sub $super (descriptor $sub-desc) (struct)))
+    ;; CHECK:       (type $sub-desc (sub $super-desc (describes $sub) (struct (field i8) (field externref) (field i32))))
+    (type $sub-desc (sub $super-desc (describes $sub) (struct (field (mut externref)) (field (mut i32)))))
+  )
+
+  ;; CHECK:       (type $4 (func (param (ref $super-desc))))
+
+  ;; CHECK:       (type $5 (func (param (ref $sub-desc))))
+
+  ;; CHECK:      (type $6 (func (result structref)))
+
+  ;; CHECK:      (export "export" (func $test))
+  (export "export" (func $test))
+  ;; CHECK:      (func $test (type $6) (result structref)
+  ;; CHECK-NEXT:  (struct.new_default_desc $super
+  ;; CHECK-NEXT:   (struct.new $super-desc
+  ;; CHECK-NEXT:    (i32.const 0)
+  ;; CHECK-NEXT:    (extern.convert_any
+  ;; CHECK-NEXT:     (struct.new_default $super-desc)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $test (result structref)
+    (struct.new_desc $super
+      (struct.new $super-desc
+        (extern.convert_any
+          (struct.new_default $super-desc)
+        )
+      )
+    )
+  )
+
+  ;; CHECK:      (func $use-super (type $4) (param $d (ref $super-desc))
+  ;; CHECK-NEXT:  (drop
+  ;; CHECK-NEXT:   (struct.get $super-desc 1
+  ;; CHECK-NEXT:    (local.get $d)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $use-super (param $d (ref $super-desc))
+    (drop
+      (struct.get $super-desc 0
+        (local.get $d)
+      )
+    )
+  )
+
+  ;; CHECK:      (func $use-sub (type $5) (param $d (ref $sub-desc))
+  ;; CHECK-NEXT:  (drop
+  ;; CHECK-NEXT:   (struct.get $sub-desc 1
+  ;; CHECK-NEXT:    (local.get $d)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT:  (drop
+  ;; CHECK-NEXT:   (struct.get $sub-desc 2
+  ;; CHECK-NEXT:    (local.get $d)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $use-sub (param $d (ref $sub-desc))
+    (drop
+      (struct.get $sub-desc 0
+        (local.get $d)
+      )
+    )
+    (drop
+      (struct.get $sub-desc 1
+        (local.get $d)
+      )
+    )
+  )
+)
+
+(module
+  ;; An exposed subtype gets a placeholder, so its non-empty supertype also gets
+  ;; a placeholder.
+  (rec
+    ;; CHECK:      (rec
+    ;; CHECK-NEXT:  (type $super (sub (descriptor $super-desc) (struct)))
+    (type $super (sub (descriptor $super-desc) (struct)))
+    ;; CHECK:       (type $super-desc (sub (describes $super) (struct (field i8) (field externref))))
+    (type $super-desc (sub (describes $super) (struct (field (mut externref)))))
+  )
+  (rec
+    ;; CHECK:       (type $sub (sub $super (descriptor $sub-desc) (struct)))
+    (type $sub (sub $super (descriptor $sub-desc) (struct)))
+    ;; CHECK:       (type $sub-desc (sub $super-desc (describes $sub) (struct (field i8) (field externref))))
+    (type $sub-desc (sub $super-desc (describes $sub) (struct (field (mut externref)))))
+  )
+
+  ;; CHECK:       (type $4 (func (param (ref $super-desc))))
+
+  ;; CHECK:      (type $5 (func (result structref)))
+
+  ;; CHECK:      (export "export" (func $test))
+  (export "export" (func $test))
+  ;; CHECK:      (func $test (type $5) (result structref)
+  ;; CHECK-NEXT:  (struct.new_default_desc $sub
+  ;; CHECK-NEXT:   (struct.new $sub-desc
+  ;; CHECK-NEXT:    (i32.const 0)
+  ;; CHECK-NEXT:    (extern.convert_any
+  ;; CHECK-NEXT:     (struct.new_default $sub-desc)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $test (result structref)
+    (struct.new_desc $sub
+      (struct.new $sub-desc
+        (extern.convert_any
+          (struct.new_default $sub-desc)
+        )
+      )
+    )
+  )
+
+  ;; CHECK:      (func $use-super (type $4) (param $d (ref $super-desc))
+  ;; CHECK-NEXT:  (drop
+  ;; CHECK-NEXT:   (struct.get $super-desc 1
+  ;; CHECK-NEXT:    (local.get $d)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $use-super (param $d (ref $super-desc))
+    (drop
+      (struct.get $super-desc 0
+        (local.get $d)
+      )
+    )
+  )
+)
+
+(module
+  ;; Multi-level subtyping: an exposed leaf subtype descriptor causes its
+  ;; grandparent descriptor (which defines field 0) to get a placeholder,
+  ;; propagating down the full inheritance chain.
+  (rec
+    ;; CHECK:      (rec
+    ;; CHECK-NEXT:  (type $grandparent (sub (descriptor $grandparent-desc) (struct)))
+    (type $grandparent (sub (descriptor $grandparent-desc) (struct)))
+    ;; CHECK:       (type $grandparent-desc (sub (describes $grandparent) (struct (field i8) (field externref))))
+    (type $grandparent-desc (sub (describes $grandparent) (struct (field (mut externref)))))
+  )
+  (rec
+    ;; CHECK:       (type $parent (sub $grandparent (descriptor $parent-desc) (struct)))
+    (type $parent (sub $grandparent (descriptor $parent-desc) (struct)))
+    ;; CHECK:       (type $parent-desc (sub $grandparent-desc (describes $parent) (struct (field i8) (field externref) (field i32))))
+    (type $parent-desc (sub $grandparent-desc (describes $parent) (struct (field (mut externref)) (field (mut i32)))))
+  )
+  (rec
+    ;; CHECK:       (type $child (sub $parent (descriptor $child-desc) (struct)))
+    (type $child (sub $parent (descriptor $child-desc) (struct)))
+    ;; CHECK:       (type $child-desc (sub $parent-desc (describes $child) (struct (field i8) (field externref) (field i32) (field i64))))
+    (type $child-desc (sub $parent-desc (describes $child) (struct (field (mut externref)) (field (mut i32)) (field (mut i64)))))
+  )
+
+  ;; CHECK:       (type $6 (func (param (ref $grandparent-desc) (ref $parent-desc) (ref $child-desc))))
+
+  ;; CHECK:      (type $7 (func (result structref)))
+
+  ;; CHECK:      (export "export" (func $test))
+  (export "export" (func $test))
+  ;; CHECK:      (func $test (type $7) (result structref)
+  ;; CHECK-NEXT:  (struct.new_default_desc $child
+  ;; CHECK-NEXT:   (struct.new $child-desc
+  ;; CHECK-NEXT:    (i32.const 0)
+  ;; CHECK-NEXT:    (extern.convert_any
+  ;; CHECK-NEXT:     (struct.new_default $child-desc)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:    (i32.const 1)
+  ;; CHECK-NEXT:    (i64.const 2)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $test (result structref)
+    (struct.new_desc $child
+      (struct.new $child-desc
+        (extern.convert_any
+          (struct.new_default $child-desc)
+        )
+        (i32.const 1)
+        (i64.const 2)
+      )
+    )
+  )
+
+  ;; CHECK:      (func $use (type $6) (param $g (ref $grandparent-desc)) (param $p (ref $parent-desc)) (param $c (ref $child-desc))
+  ;; CHECK-NEXT:  (drop
+  ;; CHECK-NEXT:   (struct.get $grandparent-desc 1
+  ;; CHECK-NEXT:    (local.get $g)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT:  (drop
+  ;; CHECK-NEXT:   (struct.get $parent-desc 2
+  ;; CHECK-NEXT:    (local.get $p)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT:  (drop
+  ;; CHECK-NEXT:   (struct.get $child-desc 3
+  ;; CHECK-NEXT:    (local.get $c)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $use (param $g (ref $grandparent-desc)) (param $p (ref $parent-desc)) (param $c (ref $child-desc))
+    (drop (struct.get $grandparent-desc 0 (local.get $g)))
+    (drop (struct.get $parent-desc 1 (local.get $p)))
+    (drop (struct.get $child-desc 2 (local.get $c)))
+  )
+)
+
+(module
+  ;; Branching subtyping: an exposed subtype causes its supertype to get a
+  ;; placeholder, which is inherited by an unexposed sibling subtype.
+  (rec
+    ;; CHECK:      (rec
+    ;; CHECK-NEXT:  (type $super (sub (descriptor $super-desc) (struct)))
+    (type $super (sub (descriptor $super-desc) (struct)))
+    ;; CHECK:       (type $super-desc (sub (describes $super) (struct (field i8) (field externref))))
+    (type $super-desc (sub (describes $super) (struct (field (mut externref)))))
+  )
+  (rec
+    ;; CHECK:       (type $sub1 (sub $super (descriptor $sub1-desc) (struct)))
+    (type $sub1 (sub $super (descriptor $sub1-desc) (struct)))
+    ;; CHECK:       (type $sub1-desc (sub $super-desc (describes $sub1) (struct (field i8) (field externref) (field i32))))
+    (type $sub1-desc (sub $super-desc (describes $sub1) (struct (field (mut externref)) (field (mut i32)))))
+  )
+  (rec
+    ;; CHECK:       (type $sub2 (sub $super (descriptor $sub2-desc) (struct)))
+    (type $sub2 (sub $super (descriptor $sub2-desc) (struct)))
+    ;; CHECK:       (type $sub2-desc (sub $super-desc (describes $sub2) (struct (field i8) (field externref) (field f64))))
+    (type $sub2-desc (sub $super-desc (describes $sub2) (struct (field (mut externref)) (field (mut f64)))))
+  )
+
+  ;; CHECK:       (type $6 (func (param (ref $super-desc))))
+
+  ;; CHECK:       (type $7 (func (param (ref $sub1-desc))))
+
+  ;; CHECK:       (type $8 (func (param (ref $sub2-desc))))
+
+  ;; CHECK:      (type $9 (func (result structref)))
+
+  ;; CHECK:      (export "export" (func $test))
+  (export "export" (func $test))
+  ;; CHECK:      (func $test (type $9) (result structref)
+  ;; CHECK-NEXT:  (struct.new_default_desc $sub1
+  ;; CHECK-NEXT:   (struct.new $sub1-desc
+  ;; CHECK-NEXT:    (i32.const 0)
+  ;; CHECK-NEXT:    (extern.convert_any
+  ;; CHECK-NEXT:     (struct.new_default $sub1-desc)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:    (i32.const 1)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $test (result structref)
+    (struct.new_desc $sub1
+      (struct.new $sub1-desc
+        (extern.convert_any
+          (struct.new_default $sub1-desc)
+        )
+        (i32.const 1)
+      )
+    )
+  )
+
+  ;; CHECK:      (func $use-super (type $6) (param $d (ref $super-desc))
+  ;; CHECK-NEXT:  (drop
+  ;; CHECK-NEXT:   (struct.get $super-desc 1
+  ;; CHECK-NEXT:    (local.get $d)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $use-super (param $d (ref $super-desc))
+    (drop (struct.get $super-desc 0 (local.get $d)))
+  )
+
+  ;; CHECK:      (func $use-sub1 (type $7) (param $d (ref $sub1-desc))
+  ;; CHECK-NEXT:  (drop
+  ;; CHECK-NEXT:   (struct.get $sub1-desc 2
+  ;; CHECK-NEXT:    (local.get $d)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $use-sub1 (param $d (ref $sub1-desc))
+    (drop (struct.get $sub1-desc 1 (local.get $d)))
+  )
+
+  ;; CHECK:      (func $use-sub2 (type $8) (param $d (ref $sub2-desc))
+  ;; CHECK-NEXT:  (drop
+  ;; CHECK-NEXT:   (struct.get $sub2-desc 1
+  ;; CHECK-NEXT:    (local.get $d)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT:  (drop
+  ;; CHECK-NEXT:   (struct.get $sub2-desc 2
+  ;; CHECK-NEXT:    (local.get $d)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $use-sub2 (param $d (ref $sub2-desc))
+    (drop (struct.get $sub2-desc 0 (local.get $d)))
+    (drop (struct.get $sub2-desc 1 (local.get $d)))
+  )
+)
+
+(module
+  ;; Field 0 is a mutable non-externref field. It can become immutable without
+  ;; exposing a prototype, so no placeholder is inserted.
+  (rec
+    ;; CHECK:      (rec
+    ;; CHECK-NEXT:  (type $struct (descriptor $desc) (struct))
+    (type $struct (descriptor $desc) (struct))
+    ;; CHECK:       (type $desc (describes $struct) (struct (field anyref) (field anyref)))
+    (type $desc (describes $struct) (struct (field (mut anyref)) (field (mut anyref))))
+  )
+
+  ;; CHECK:       (type $2 (func (param (ref $desc))))
+
+  ;; CHECK:      (type $3 (func (result structref)))
+
+  ;; CHECK:      (export "export" (func $test))
+  (export "export" (func $test))
+  ;; CHECK:      (func $test (type $3) (result structref)
+  ;; CHECK-NEXT:  (struct.new_default_desc $struct
+  ;; CHECK-NEXT:   (struct.new $desc
+  ;; CHECK-NEXT:    (ref.null none)
+  ;; CHECK-NEXT:    (ref.null none)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $test (result structref)
+    (struct.new_desc $struct
+      (struct.new $desc
+        (ref.null any)
+        (ref.null any)
+      )
+    )
+  )
+
+  ;; CHECK:      (func $use (type $2) (param $d (ref $desc))
+  ;; CHECK-NEXT:  (drop
+  ;; CHECK-NEXT:   (struct.get $desc 0
+  ;; CHECK-NEXT:    (local.get $d)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT:  (drop
+  ;; CHECK-NEXT:   (struct.get $desc 1
+  ;; CHECK-NEXT:    (local.get $d)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $use (param $d (ref $desc))
+    (drop (struct.get $desc 0 (local.get $d)))
+    (drop (struct.get $desc 1 (local.get $d)))
+  )
+)
+
+(module
+  ;; Field 0 is removed, and field 1 is an immutable non-externref field, so
+  ;; shifting it to index 0 does not expose a prototype and no placeholder is
+  ;; inserted.
+  (rec
+    ;; CHECK:      (rec
+    ;; CHECK-NEXT:  (type $struct (descriptor $desc) (struct))
+    (type $struct (descriptor $desc) (struct))
+    ;; CHECK:       (type $desc (describes $struct) (struct (field anyref)))
+    (type $desc (describes $struct) (struct (field i64) (field anyref)))
+  )
+
+  ;; CHECK:       (type $2 (func (param (ref $desc))))
+
+  ;; CHECK:      (type $3 (func (result structref)))
+
+  ;; CHECK:      (export "export" (func $test))
+  (export "export" (func $test))
+  ;; CHECK:      (func $test (type $3) (result structref)
+  ;; CHECK-NEXT:  (struct.new_default_desc $struct
+  ;; CHECK-NEXT:   (struct.new $desc
+  ;; CHECK-NEXT:    (ref.null none)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $test (result structref)
+    (struct.new_desc $struct
+      (struct.new $desc
+        (i64.const 100)
+        (ref.null any)
+      )
+    )
+  )
+
+  ;; CHECK:      (func $use (type $2) (param $d (ref $desc))
+  ;; CHECK-NEXT:  (drop
+  ;; CHECK-NEXT:   (struct.get $desc 0
+  ;; CHECK-NEXT:    (local.get $d)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $use (param $d (ref $desc))
+    (drop (struct.get $desc 1 (local.get $d)))
+  )
+)
+
+(module
+  ;; All fields of an exposed descriptor are unused and removed, resulting in an
+  ;; empty descriptor (struct). No placeholder is needed.
+  (rec
+    ;; CHECK:      (rec
+    ;; CHECK-NEXT:  (type $struct (descriptor $desc) (struct))
+    (type $struct (descriptor $desc) (struct))
+    ;; CHECK:       (type $desc (describes $struct) (struct))
+    (type $desc (describes $struct) (struct (field (mut externref)) (field i32)))
+  )
+
+  ;; CHECK:      (type $2 (func (result structref)))
+
+  ;; CHECK:      (export "export" (func $test))
+  (export "export" (func $test))
+  ;; CHECK:      (func $test (type $2) (result structref)
+  ;; CHECK-NEXT:  (struct.new_default_desc $struct
+  ;; CHECK-NEXT:   (struct.new_default $desc)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $test (result structref)
+    (struct.new_desc $struct
+      (struct.new $desc
+        (extern.convert_any
+          (struct.new_default $desc)
+        )
+        (i32.const 42)
+      )
+    )
+  )
+)
+
+(module
+  ;; Exact type on the JS boundary: an exact (ref (exact $super)) does not
+  ;; propagate exposure to $sub-desc, so $sub-desc does not get an unnecessary
+  ;; placeholder when $super-desc is empty.
+  (rec
+    ;; CHECK:      (rec
+    ;; CHECK-NEXT:  (type $super (sub (descriptor $super-desc) (struct)))
+    (type $super (sub (descriptor $super-desc) (struct)))
+    ;; CHECK:       (type $super-desc (sub (describes $super) (struct)))
+    (type $super-desc (sub (describes $super) (struct)))
+  )
+  (rec
+    ;; CHECK:      (rec
+    ;; CHECK-NEXT:  (type $sub (sub $super (descriptor $sub-desc) (struct)))
+    (type $sub (sub $super (descriptor $sub-desc) (struct)))
+    ;; CHECK:       (type $sub-desc (sub $super-desc (describes $sub) (struct (field externref))))
+    (type $sub-desc (sub $super-desc (describes $sub) (struct (field (mut externref)))))
+  )
+
+  ;; CHECK:       (type $4 (func (param (ref $sub-desc))))
+
+  ;; CHECK:      (type $5 (func (param (ref null (exact $super)))))
+
+  ;; CHECK:      (import "" "" (func $import (type $5) (param (ref null (exact $super)))))
+  (import "" "" (func $import (param (ref null (exact $super)))))
+
+  ;; CHECK:      (func $use-sub (type $4) (param $d (ref $sub-desc))
+  ;; CHECK-NEXT:  (drop
+  ;; CHECK-NEXT:   (struct.get $sub-desc 0
+  ;; CHECK-NEXT:    (local.get $d)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $use-sub (param $d (ref $sub-desc))
+    (drop (struct.get $sub-desc 0 (local.get $d)))
+  )
+)
+
+(module
+  ;; Exact type flowing into extern.convert_any: an exact
+  ;; (extern.convert_any (ref (exact $super))) does not propagate exposure to
+  ;; $sub-desc, so $sub-desc does not get an unnecessary placeholder when
+  ;; $super-desc is empty.
+  (rec
+    ;; CHECK:      (rec
+    ;; CHECK-NEXT:  (type $super (sub (descriptor $super-desc) (struct)))
+    (type $super (sub (descriptor $super-desc) (struct)))
+    ;; CHECK:       (type $super-desc (sub (describes $super) (struct)))
+    (type $super-desc (sub (describes $super) (struct)))
+  )
+  (rec
+    ;; CHECK:       (type $sub (sub $super (descriptor $sub-desc) (struct)))
+    (type $sub (sub $super (descriptor $sub-desc) (struct)))
+    ;; CHECK:       (type $sub-desc (sub $super-desc (describes $sub) (struct (field externref))))
+    (type $sub-desc (sub $super-desc (describes $sub) (struct (field (mut externref)))))
+  )
+
+  ;; CHECK:       (type $4 (func (param (ref null (exact $super)))))
+
+  ;; CHECK:       (type $5 (func (param (ref $sub-desc))))
+
+  ;; CHECK:      (func $test (type $4) (param $s (ref null (exact $super)))
+  ;; CHECK-NEXT:  (drop
+  ;; CHECK-NEXT:   (extern.convert_any
+  ;; CHECK-NEXT:    (local.get $s)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $test (param $s (ref null (exact $super)))
+    (drop
+      (extern.convert_any
+        (local.get $s)
+      )
+    )
+  )
+
+  ;; CHECK:      (func $use-sub (type $5) (param $d (ref $sub-desc))
+  ;; CHECK-NEXT:  (drop
+  ;; CHECK-NEXT:   (struct.get $sub-desc 0
+  ;; CHECK-NEXT:    (local.get $d)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $use-sub (param $d (ref $sub-desc))
+    (drop (struct.get $sub-desc 0 (local.get $d)))
+  )
+)
+
+(module
+  ;; An exposed descriptor that receives a placeholder is also used directly
+  ;; with struct.get / struct.set / struct.new; all instruction operands and
+  ;; field indices are shifted correctly.
+  (rec
+    ;; CHECK:      (rec
+    ;; CHECK-NEXT:  (type $struct (descriptor $desc) (struct))
+    (type $struct (descriptor $desc) (struct))
+    ;; CHECK:       (type $desc (describes $struct) (struct (field i8) (field externref) (field (mut i32))))
+    (type $desc (describes $struct) (struct (field (mut externref)) (field (mut i32))))
+  )
+
+  ;; CHECK:       (type $2 (func (param (ref $desc)) (result (ref $desc))))
+
+  ;; CHECK:      (type $3 (func (result structref)))
+
+  ;; CHECK:      (export "export" (func $test))
+  (export "export" (func $test))
+  ;; CHECK:      (func $test (type $3) (result structref)
+  ;; CHECK-NEXT:  (struct.new_default_desc $struct
+  ;; CHECK-NEXT:   (struct.new $desc
+  ;; CHECK-NEXT:    (i32.const 0)
+  ;; CHECK-NEXT:    (extern.convert_any
+  ;; CHECK-NEXT:     (struct.new_default $desc)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:    (i32.const 42)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $test (result structref)
+    (struct.new_desc $struct
+      (struct.new $desc
+        (extern.convert_any
+          (struct.new_default $desc)
+        )
+        (i32.const 42)
+      )
+    )
+  )
+
+  ;; CHECK:      (func $manipulate (type $2) (param $d (ref $desc)) (result (ref $desc))
+  ;; CHECK-NEXT:  (struct.set $desc 2
+  ;; CHECK-NEXT:   (local.get $d)
+  ;; CHECK-NEXT:   (i32.const 100)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT:  (drop
+  ;; CHECK-NEXT:   (struct.get $desc 1
+  ;; CHECK-NEXT:    (local.get $d)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT:  (drop
+  ;; CHECK-NEXT:   (struct.get $desc 2
+  ;; CHECK-NEXT:    (local.get $d)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT:  (struct.new $desc
+  ;; CHECK-NEXT:   (i32.const 0)
+  ;; CHECK-NEXT:   (ref.null noextern)
+  ;; CHECK-NEXT:   (i32.const 200)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $manipulate (param $d (ref $desc)) (result (ref $desc))
+    (struct.set $desc 1
+      (local.get $d)
+      (i32.const 100)
+    )
+    (drop
+      (struct.get $desc 0
+        (local.get $d)
+      )
+    )
+    (drop
+      (struct.get $desc 1
+        (local.get $d)
+      )
+    )
+    (struct.new $desc
+      (ref.null extern)
+      (i32.const 200)
+    )
+  )
+)
+
+(module
+  ;; A struct descriptor has an initial nullexternref field and a subsequent
+  ;; externref field. The initial nullexternref field does not expose a JS
+  ;; prototype. Removing the unread nullexternref field causes the externref
+  ;; field to shift to index 0. Because the descriptor has no prototype, an i8
+  ;; placeholder is inserted at index 0 to keep the externref field at index 1.
+  (rec
+    ;; CHECK:      (rec
+    ;; CHECK-NEXT:  (type $struct (sub (descriptor $desc) (struct)))
+    (type $struct (sub (descriptor $desc) (struct)))
+    ;; CHECK:       (type $desc (sub (describes $struct) (struct (field i8) (field externref))))
+    (type $desc (sub (describes $struct) (struct (field nullexternref) (field externref))))
+  )
+
+  ;; CHECK:       (type $2 (func (param (ref $desc)) (result externref)))
+
+  ;; CHECK:      (type $3 (func (result externref)))
+
+  ;; CHECK:      (import "env" "ext" (global $ext externref))
+  (import "env" "ext" (global $ext externref))
+  ;; CHECK:      (export "export" (func $test))
+  (export "export" (func $test))
+
+  ;; CHECK:      (func $test (type $3) (result externref)
+  ;; CHECK-NEXT:  (extern.convert_any
+  ;; CHECK-NEXT:   (struct.new_default_desc $struct
+  ;; CHECK-NEXT:    (struct.new $desc
+  ;; CHECK-NEXT:     (i32.const 0)
+  ;; CHECK-NEXT:     (global.get $ext)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $test (result externref)
+    (extern.convert_any
+      (struct.new_default_desc $struct
+        (struct.new $desc
+          (ref.null noextern)
+          (global.get $ext)
+        )
+      )
+    )
+  )
+
+  ;; CHECK:      (func $use (type $2) (param $d (ref $desc)) (result externref)
+  ;; CHECK-NEXT:  (struct.get $desc 1
+  ;; CHECK-NEXT:   (local.get $d)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $use (param $d (ref $desc)) (result externref)
+    (struct.get $desc 1
+      (local.get $d)
+    )
+  )
+)
+
+(module
+  ;; The supertype descriptor has an externref prototype field. The subtype
+  ;; descriptor narrows the prototype field to nullexternref. The supertype
+  ;; descriptor exposes a prototype and must not have exposedNoProtoDescs
+  ;; propagated to it from the subtype descriptor, so it does not get an i8
+  ;; placeholder inserted.
+  (rec
+    ;; CHECK:      (rec
+    ;; CHECK-NEXT:  (type $super (sub (descriptor $super-desc) (struct)))
+    (type $super (sub (descriptor $super-desc) (struct)))
+    ;; CHECK:       (type $sub (sub final $super (descriptor $sub-desc) (struct)))
+    (type $sub (sub final $super (descriptor $sub-desc) (struct)))
+    ;; CHECK:       (type $super-desc (sub (describes $super) (struct (field externref))))
+    (type $super-desc (sub (describes $super) (struct (field externref))))
+    ;; CHECK:       (type $sub-desc (sub final $super-desc (describes $sub) (struct (field nullexternref))))
+    (type $sub-desc (sub final $super-desc (describes $sub) (struct (field nullexternref))))
+  )
+
+  ;; CHECK:      (type $4 (func (result externref)))
+
+  ;; CHECK:      (import "env" "ext" (global $ext externref))
+  (import "env" "ext" (global $ext externref))
+  ;; CHECK:      (export "export" (func $test))
+  (export "export" (func $test))
+
+  ;; CHECK:      (func $test (type $4) (result externref)
+  ;; CHECK-NEXT:  (extern.convert_any
+  ;; CHECK-NEXT:   (struct.new_default_desc $super
+  ;; CHECK-NEXT:    (struct.new $super-desc
+  ;; CHECK-NEXT:     (global.get $ext)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $test (result externref)
+    (extern.convert_any
+      (struct.new_default_desc $super
+        (struct.new $super-desc
+          (global.get $ext)
+        )
+      )
+    )
+  )
+)
+
+(module
+  ;; A struct.get on a descriptor that receives an i8 placeholder is nested
+  ;; inside a struct.new whose field is removed. FieldRemover runs
+  ;; ChildLocalizer (which uses EffectAnalyzer) on the struct.new before
+  ;; IndexUpdater increments the struct.get index, avoiding an out-of-bounds
+  ;; access into the old struct type's fields.
+  (rec
+    ;; CHECK:      (rec
+    ;; CHECK-NEXT:  (type $struct (descriptor $desc) (struct))
+    (type $struct (descriptor $desc) (struct (field externref)))
+    ;; CHECK:       (type $desc (describes $struct) (struct (field i8) (field externref)))
+    (type $desc (describes $struct) (struct (field (mut externref))))
+  )
+
+  ;; CHECK:      (type $2 (func (result structref)))
+
+  ;; CHECK:      (export "export" (func $test))
+  (export "export" (func $test))
+
+  ;; CHECK:      (func $test (type $2) (result structref)
+  ;; CHECK-NEXT:  (local $d (ref null $desc))
+  ;; CHECK-NEXT:  (local $1 externref)
+  ;; CHECK-NEXT:  (local.set $1
+  ;; CHECK-NEXT:   (struct.get $desc 1
+  ;; CHECK-NEXT:    (local.get $d)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT:  (struct.new_default_desc $struct
+  ;; CHECK-NEXT:   (struct.new_default $desc)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $test (result structref)
+    (local $d (ref null $desc))
+    (struct.new_desc $struct
+      (struct.get $desc 0
+        (local.get $d)
+      )
+      (struct.new_default $desc)
+    )
+  )
+)
diff --git a/test/lit/passes/gto-removals.wast b/test/lit/passes/gto-removals.wast
index 814712bccc4..f0000775bfc 100644
--- a/test/lit/passes/gto-removals.wast
+++ b/test/lit/passes/gto-removals.wast
@@ -788,7 +788,7 @@
 )
 
 ;; A parent with two children, and there are only reads of the parent. Those
-;; reads might be of data of either child, of course (as a refernce to the
+;; reads might be of data of either child, of course (as a reference to the
 ;; parent might point to them), so we cannot optimize here.
 (module
   (rec
diff --git a/test/lit/passes/gufa-cont.wast b/test/lit/passes/gufa-cont.wast
index d35e77a60ef..a4d5b6c4a3a 100644
--- a/test/lit/passes/gufa-cont.wast
+++ b/test/lit/passes/gufa-cont.wast
@@ -44,6 +44,10 @@
 
  ;; CHECK:      (export "resume-i32" (func $resume-i32))
 
+ ;; CHECK:      (export "resume-switch" (func $resume-switch))
+
+ ;; CHECK:      (export "resume_throw-switch" (func $resume_throw-switch))
+
  ;; CHECK:      (func $cont (type $func)
  ;; CHECK-NEXT:  (suspend $tag)
  ;; CHECK-NEXT: )
@@ -53,6 +57,10 @@
 
  ;; OPEN_WORLD:      (export "resume-i32" (func $resume-i32))
 
+ ;; OPEN_WORLD:      (export "resume-switch" (func $resume-switch))
+
+ ;; OPEN_WORLD:      (export "resume_throw-switch" (func $resume_throw-switch))
+
  ;; OPEN_WORLD:      (func $cont (type $func)
  ;; OPEN_WORLD-NEXT:  (suspend $tag)
  ;; OPEN_WORLD-NEXT: )
@@ -195,6 +203,58 @@
    )
   )
  )
+
+ ;; CHECK:      (func $resume-switch (type $func)
+ ;; CHECK-NEXT:  (resume $cont (on $tag switch)
+ ;; CHECK-NEXT:   (cont.new $cont
+ ;; CHECK-NEXT:    (ref.func $cont)
+ ;; CHECK-NEXT:   )
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT: )
+ ;; OPEN_WORLD:      (func $resume-switch (type $func)
+ ;; OPEN_WORLD-NEXT:  (resume $cont (on $tag switch)
+ ;; OPEN_WORLD-NEXT:   (cont.new $cont
+ ;; OPEN_WORLD-NEXT:    (ref.func $cont)
+ ;; OPEN_WORLD-NEXT:   )
+ ;; OPEN_WORLD-NEXT:  )
+ ;; OPEN_WORLD-NEXT: )
+ (func $resume-switch (export "resume-switch")
+  ;; Switch handlers do not branch to a target block. Ensure GUFA does not
+  ;; attempt to look up a target block name (which would incorrectly find an
+  ;; unnamed block in scope or null) and crash.
+  (block
+   (resume $cont (on $tag switch)
+    (cont.new $cont
+     (ref.func $cont)
+    )
+   )
+  )
+ )
+
+ ;; CHECK:      (func $resume_throw-switch (type $func)
+ ;; CHECK-NEXT:  (resume_throw $cont $tag (on $tag switch)
+ ;; CHECK-NEXT:   (cont.new $cont
+ ;; CHECK-NEXT:    (ref.func $cont)
+ ;; CHECK-NEXT:   )
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT: )
+ ;; OPEN_WORLD:      (func $resume_throw-switch (type $func)
+ ;; OPEN_WORLD-NEXT:  (resume_throw $cont $tag (on $tag switch)
+ ;; OPEN_WORLD-NEXT:   (cont.new $cont
+ ;; OPEN_WORLD-NEXT:    (ref.func $cont)
+ ;; OPEN_WORLD-NEXT:   )
+ ;; OPEN_WORLD-NEXT:  )
+ ;; OPEN_WORLD-NEXT: )
+ (func $resume_throw-switch (export "resume_throw-switch")
+  ;; As above, but with resume_throw.
+  (block
+   (resume_throw $cont $tag (on $tag switch)
+    (cont.new $cont
+     (ref.func $cont)
+    )
+   )
+  )
+ )
 )
 
 (module
diff --git a/test/lit/passes/gufa-desc.wast b/test/lit/passes/gufa-desc.wast
index 351db702c3a..5d553a1434c 100644
--- a/test/lit/passes/gufa-desc.wast
+++ b/test/lit/passes/gufa-desc.wast
@@ -87,7 +87,7 @@
   ;; CHECK-NEXT: )
   (func $struct (export "struct")
     ;; Show we don't disrupt normal struct field inference. Field 1 is
-    ;; particuarly interesting as we represent descriptors as field -1
+    ;; particularly interesting as we represent descriptors as field -1
     ;; internally.
     (drop
       (struct.get $struct 0
diff --git a/test/lit/passes/gufa-tnh.wast b/test/lit/passes/gufa-tnh.wast
index b4601d47661..e47919f6d49 100644
--- a/test/lit/passes/gufa-tnh.wast
+++ b/test/lit/passes/gufa-tnh.wast
@@ -801,7 +801,7 @@
   (func $caller (export "out") (param $any anyref)
     ;; All three params get similar blocks+casts, but the middle one might
     ;; transfer control flow, so we cannot optimize the first parameter (we
-    ;; might not reach the call, so we can't assume the call's cast suceeds).
+    ;; might not reach the call, so we can't assume the call's cast succeeds).
     ;; As a result, only the last two casts are refined to $B, but not the
     ;; first.
     (call $called
diff --git a/test/lit/passes/heap2local-desc.wast b/test/lit/passes/heap2local-desc.wast
index f7d18cd64f1..4691485216a 100644
--- a/test/lit/passes/heap2local-desc.wast
+++ b/test/lit/passes/heap2local-desc.wast
@@ -870,8 +870,8 @@
     ;; CHECK:      (rec
     ;; CHECK-NEXT:  (type $struct (sub (descriptor $desc) (struct)))
     (type $struct (sub (descriptor $desc) (struct)))
-    ;; CHECK:       (type $desc (describes $struct) (struct))
-    (type $desc (describes $struct) (struct))
+    ;; CHECK:       (type $desc (sub (describes $struct) (struct)))
+    (type $desc (sub (describes $struct) (struct)))
   )
 
   ;; CHECK:      (type $2 (func (result (ref (exact $desc)))))
@@ -1016,7 +1016,7 @@
 (module
   (rec
     (type $A (descriptor $B) (struct))
-    (type $B (sub (describes $A) (struct)))
+    (type $B (describes $A) (struct))
   )
   ;; CHECK:      (type $0 (func))
 
@@ -1156,8 +1156,8 @@
 (module
   (rec
     ;; CHECK:      (rec
-    ;; CHECK-NEXT:  (type $A (shared (descriptor $B) (struct)))
-    (type $A (shared (descriptor $B) (struct)))
+    ;; CHECK-NEXT:  (type $A (sub (shared (descriptor $B) (struct))))
+    (type $A (sub (shared (descriptor $B) (struct))))
     ;; CHECK:       (type $B (sub (shared (describes $A) (descriptor $C) (struct))))
     (type $B (sub (shared (describes $A) (descriptor $C) (struct))))
     ;; CHECK:       (type $C (sub (shared (describes $B) (struct))))
@@ -1229,10 +1229,10 @@
 (module
   (rec
    ;; CHECK:      (rec
-   ;; CHECK-NEXT:  (type $struct (sub (descriptor $desc) (struct)))
-   (type $struct (sub (descriptor $desc) (struct)))
+   ;; CHECK-NEXT:  (type $struct (descriptor $desc) (struct))
+   (type $struct (descriptor $desc) (struct))
    ;; CHECK:       (type $desc (describes $struct) (struct))
-   (type $desc (sub final (describes $struct) (struct)))
+   (type $desc (describes $struct) (struct))
   )
 
   ;; CHECK:      (type $2 (func (result i32)))
@@ -1293,8 +1293,8 @@
     ;; CHECK:      (rec
     ;; CHECK-NEXT:  (type $struct (descriptor $desc) (struct))
     (type $struct (descriptor $desc) (struct))
-    ;; CHECK:       (type $desc (sub (describes $struct) (struct (field funcref))))
-    (type $desc (sub (describes $struct) (struct (field funcref))))
+    ;; CHECK:       (type $desc (describes $struct) (struct (field funcref)))
+    (type $desc (describes $struct) (struct (field funcref)))
   )
 
   ;; CHECK:      (type $2 (func))
@@ -1374,8 +1374,8 @@
     ;; CHECK:      (rec
     ;; CHECK-NEXT:  (type $struct (descriptor $desc) (struct))
     (type $struct (descriptor $desc) (struct))
-    ;; CHECK:       (type $desc (sub (describes $struct) (struct)))
-    (type $desc (sub (describes $struct) (struct)))
+    ;; CHECK:       (type $desc (describes $struct) (struct))
+    (type $desc (describes $struct) (struct))
   )
 
   ;; CHECK:      (type $2 (func))
diff --git a/test/lit/passes/inlining-eh-legacy.wast b/test/lit/passes/inlining-eh-legacy.wast
index ca005fc7c58..ac59e520211 100644
--- a/test/lit/passes/inlining-eh-legacy.wast
+++ b/test/lit/passes/inlining-eh-legacy.wast
@@ -121,7 +121,7 @@
       (do)
       (catch $tag$0
         ;; After this $callee-b is inlined, there will be an additional block
-        ;; surrouding this 'pop'. However, that block has no breaks to it, and
+        ;; surrounding this 'pop'. However, that block has no breaks to it, and
         ;; will be considered the implicit block of the catch scope, so no
         ;; fixups are done.
         (call $callee-b
diff --git a/test/lit/passes/inlining-optimizing.wast b/test/lit/passes/inlining-optimizing.wast
index 86553174d73..2c1a73dfa3c 100644
--- a/test/lit/passes/inlining-optimizing.wast
+++ b/test/lit/passes/inlining-optimizing.wast
@@ -24,7 +24,7 @@
  (func $1
   ;; $0 will be inlined into here. We will then optimize this function - but
   ;; we do so *without* optimizing $0 (as inlining-optimizing only optimizes
-  ;; where it inlines, for efficiency). As part of the optimiziations, we will
+  ;; where it inlines, for efficiency). As part of the optimizations, we will
   ;; try to precompute the cast here, which will try to look up $0. We should
   ;; not hit an assertion, rather we should skip precomputing it, the same as if
   ;; we were optimizing $1 before $0 were added to the module. (In fact, we will
diff --git a/test/lit/passes/inlining-optimizing_optimize-level=3.wast b/test/lit/passes/inlining-optimizing_optimize-level=3.wast
index f6df7305620..bf931609666 100644
--- a/test/lit/passes/inlining-optimizing_optimize-level=3.wast
+++ b/test/lit/passes/inlining-optimizing_optimize-level=3.wast
@@ -9443,47 +9443,36 @@
  ;; CHECK-NEXT:          )
  ;; CHECK-NEXT:         )
  ;; CHECK-NEXT:        )
- ;; CHECK-NEXT:        (if (result i32)
- ;; CHECK-NEXT:         (i32.lt_s
- ;; CHECK-NEXT:          (local.get $0)
- ;; CHECK-NEXT:          (i32.const 10)
- ;; CHECK-NEXT:         )
- ;; CHECK-NEXT:         (then
- ;; CHECK-NEXT:          (loop $while-in132 (result i32)
- ;; CHECK-NEXT:           (if
- ;; CHECK-NEXT:            (i32.load
- ;; CHECK-NEXT:             (i32.add
- ;; CHECK-NEXT:              (local.get $4)
- ;; CHECK-NEXT:              (i32.shl
- ;; CHECK-NEXT:               (local.get $0)
- ;; CHECK-NEXT:               (i32.const 2)
- ;; CHECK-NEXT:              )
- ;; CHECK-NEXT:             )
- ;; CHECK-NEXT:            )
- ;; CHECK-NEXT:            (then
- ;; CHECK-NEXT:             (local.set $17
- ;; CHECK-NEXT:              (i32.const -1)
- ;; CHECK-NEXT:             )
- ;; CHECK-NEXT:             (br $label$break$L343)
+ ;; CHECK-NEXT:        (loop $while-in132 (result i32)
+ ;; CHECK-NEXT:         (if
+ ;; CHECK-NEXT:          (i32.load
+ ;; CHECK-NEXT:           (i32.add
+ ;; CHECK-NEXT:            (local.get $4)
+ ;; CHECK-NEXT:            (i32.shl
+ ;; CHECK-NEXT:             (local.get $0)
+ ;; CHECK-NEXT:             (i32.const 2)
  ;; CHECK-NEXT:            )
  ;; CHECK-NEXT:           )
- ;; CHECK-NEXT:           (br_if $while-in132
- ;; CHECK-NEXT:            (i32.lt_s
- ;; CHECK-NEXT:             (local.tee $0
- ;; CHECK-NEXT:              (i32.add
- ;; CHECK-NEXT:               (local.get $0)
- ;; CHECK-NEXT:               (i32.const 1)
- ;; CHECK-NEXT:              )
- ;; CHECK-NEXT:             )
- ;; CHECK-NEXT:             (i32.const 10)
- ;; CHECK-NEXT:            )
+ ;; CHECK-NEXT:          )
+ ;; CHECK-NEXT:          (then
+ ;; CHECK-NEXT:           (local.set $17
+ ;; CHECK-NEXT:            (i32.const -1)
  ;; CHECK-NEXT:           )
- ;; CHECK-NEXT:           (i32.const 1)
+ ;; CHECK-NEXT:           (br $label$break$L343)
  ;; CHECK-NEXT:          )
  ;; CHECK-NEXT:         )
- ;; CHECK-NEXT:         (else
- ;; CHECK-NEXT:          (i32.const 1)
+ ;; CHECK-NEXT:         (br_if $while-in132
+ ;; CHECK-NEXT:          (i32.lt_s
+ ;; CHECK-NEXT:           (local.tee $0
+ ;; CHECK-NEXT:            (i32.add
+ ;; CHECK-NEXT:             (local.get $0)
+ ;; CHECK-NEXT:             (i32.const 1)
+ ;; CHECK-NEXT:            )
+ ;; CHECK-NEXT:           )
+ ;; CHECK-NEXT:           (i32.const 10)
+ ;; CHECK-NEXT:          )
  ;; CHECK-NEXT:         )
+ ;; CHECK-NEXT:         (i32.const 1)
  ;; CHECK-NEXT:        )
  ;; CHECK-NEXT:       )
  ;; CHECK-NEXT:       (else
diff --git a/test/lit/passes/inlining_optimize-level=3.wast b/test/lit/passes/inlining_optimize-level=3.wast
index dc35fb10b23..3a98818885d 100644
--- a/test/lit/passes/inlining_optimize-level=3.wast
+++ b/test/lit/passes/inlining_optimize-level=3.wast
@@ -567,7 +567,7 @@
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $middle3 (param $x i32) (param $y i32) (param $z i32)
-  ;; Not trivial, becaues of the eqz.
+  ;; Not trivial, because of the eqz.
   (call $top
    (local.get $z)
    (i32.eqz
diff --git a/test/lit/passes/intrinsic-lowering.wast b/test/lit/passes/intrinsic-lowering.wast
index e8897ff0b25..51ae5788c73 100644
--- a/test/lit/passes/intrinsic-lowering.wast
+++ b/test/lit/passes/intrinsic-lowering.wast
@@ -6,18 +6,18 @@
   (type $none (func))
 
   ;; call.without.effects with no params.
-  ;; CHECK:      (import "binaryen-intrinsics" "call.without.effects" (func $cwe-v (type $1) (param funcref) (result i32)))
+  ;; CHECK:      (import "binaryen-intrinsics" "call.without.effects" (func $cwe-v (type $3) (param funcref) (result i32)))
   (import "binaryen-intrinsics" "call.without.effects" (func $cwe-v (param funcref) (result i32)))
 
   ;; call.without.effects with some params.
-  ;; CHECK:      (import "binaryen-intrinsics" "call.without.effects" (func $cwe-dif (type $2) (param f64 i32 funcref) (result f32)))
+  ;; CHECK:      (import "binaryen-intrinsics" "call.without.effects" (func $cwe-dif (type $4) (param f64 i32 funcref) (result f32)))
   (import "binaryen-intrinsics" "call.without.effects" (func $cwe-dif (param f64) (param i32) (param funcref) (result f32)))
 
   ;; call.without.effects with no result.
-  ;; CHECK:      (import "binaryen-intrinsics" "call.without.effects" (func $cwe-n (type $3) (param funcref)))
+  ;; CHECK:      (import "binaryen-intrinsics" "call.without.effects" (func $cwe-n (type $5) (param funcref)))
   (import "binaryen-intrinsics" "call.without.effects" (func $cwe-n (param funcref)))
 
-  ;; CHECK:      (func $test (type $4) (param $none (ref null $none))
+  ;; CHECK:      (func $test (type $1) (param $none (ref null $none))
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (call $make-i32)
   ;; CHECK-NEXT:  )
@@ -39,7 +39,7 @@
     (call $cwe-n (local.get $none))
   )
 
-  ;; CHECK:      (func $make-i32 (type $5) (result i32)
+  ;; CHECK:      (func $make-i32 (type $2) (result i32)
   ;; CHECK-NEXT:  (i32.const 1)
   ;; CHECK-NEXT: )
   (func $make-i32 (result i32)
@@ -53,4 +53,20 @@
     ;; Helper function for the above.
     (unreachable)
   )
+
+  ;; CHECK:      (func $test-return-call (type $2) (result i32)
+  ;; CHECK-NEXT:  (return_call $make-i32)
+  ;; CHECK-NEXT: )
+  (func $test-return-call (result i32)
+    (return_call $cwe-v (ref.func $make-i32))
+  )
+
+  ;; CHECK:      (func $test-return-call-ref (type $1) (param $none (ref null $none))
+  ;; CHECK-NEXT:  (return_call_ref $none
+  ;; CHECK-NEXT:   (local.get $none)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $test-return-call-ref (param $none (ref null $none))
+    (return_call $cwe-n (local.get $none))
+  )
 )
diff --git a/test/lit/passes/make-shared-objects.wast b/test/lit/passes/make-shared-objects.wast
index efd48f7ed83..f9713a4b4c3 100644
--- a/test/lit/passes/make-shared-objects.wast
+++ b/test/lit/passes/make-shared-objects.wast
@@ -626,8 +626,6 @@
 
   ;; CHECK:      (table $funcs 0 0 funcref)
 
-  ;; CHECK:      (elem $funcs (i32.const 0))
-
   ;; CHECK:      (func $ref-test-func (type $1) (param $0 (ref null (shared i31))) (result i32)
   ;; CHECK-NEXT:  (ref.test (ref (shared i31))
   ;; CHECK-NEXT:   (local.get $0)
@@ -1466,3 +1464,1029 @@
     )
   )
 )
+
+(module
+  ;; Extern references entering and exiting via imports and exports are wrapped.
+  (import "env" "import_extern" (func $im (param externref i32) (result externref)))
+
+  ;; CHECK:      (type $0 (func (param (ref null (shared i31)) i32) (result (ref null (shared i31)))))
+
+  ;; CHECK:      (type $1 (func (param (ref null (shared i31))) (result (ref null (shared i31)))))
+
+  ;; CHECK:      (type $2 (func (param externref i32) (result externref)))
+
+  ;; CHECK:      (type $3 (func (param externref) (result externref)))
+
+  ;; CHECK:      (type $4 (func (param externref) (result (ref null (shared i31)))))
+
+  ;; CHECK:      (type $5 (func (param (ref null (shared i31))) (result externref)))
+
+  ;; CHECK:      (import "env" "import_extern" (func $im$import (type $2) (param externref i32) (result externref)))
+
+  ;; CHECK:      (table $externs 0 externref)
+
+  ;; CHECK:      (export "export_extern" (func $test$export))
+
+  ;; CHECK:      (func $im (type $0) (param $0 (ref null (shared i31))) (param $1 i32) (result (ref null (shared i31)))
+  ;; CHECK-NEXT:  (call $extern_to_index
+  ;; CHECK-NEXT:   (call $im$import
+  ;; CHECK-NEXT:    (call $index_to_extern
+  ;; CHECK-NEXT:     (local.get $0)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:    (local.get $1)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+
+  ;; CHECK:      (func $test (type $1) (param $e (ref null (shared i31))) (result (ref null (shared i31)))
+  ;; CHECK-NEXT:  (call $im
+  ;; CHECK-NEXT:   (local.get $e)
+  ;; CHECK-NEXT:   (i32.const 42)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $test (export "export_extern") (param $e externref) (result externref)
+    (call $im (local.get $e) (i32.const 42))
+  )
+)
+
+;; CHECK:      (func $test$export (type $3) (param $0 externref) (result externref)
+;; CHECK-NEXT:  (call $index_to_extern
+;; CHECK-NEXT:   (call $test
+;; CHECK-NEXT:    (call $extern_to_index
+;; CHECK-NEXT:     (local.get $0)
+;; CHECK-NEXT:    )
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:  )
+;; CHECK-NEXT: )
+
+;; CHECK:      (func $extern_to_index (type $4) (param $0 externref) (result (ref null (shared i31)))
+;; CHECK-NEXT:  (local $1 i32)
+;; CHECK-NEXT:  (if (result (ref null (shared i31)))
+;; CHECK-NEXT:   (ref.is_null
+;; CHECK-NEXT:    (local.get $0)
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:   (then
+;; CHECK-NEXT:    (ref.null (shared none))
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:   (else
+;; CHECK-NEXT:    (if (result (ref (shared i31)))
+;; CHECK-NEXT:     (i32.ge_s
+;; CHECK-NEXT:      (local.tee $1
+;; CHECK-NEXT:       (table.grow $externs
+;; CHECK-NEXT:        (local.get $0)
+;; CHECK-NEXT:        (i32.const 1)
+;; CHECK-NEXT:       )
+;; CHECK-NEXT:      )
+;; CHECK-NEXT:      (i32.const 0)
+;; CHECK-NEXT:     )
+;; CHECK-NEXT:     (then
+;; CHECK-NEXT:      (ref.i31_shared
+;; CHECK-NEXT:       (local.get $1)
+;; CHECK-NEXT:      )
+;; CHECK-NEXT:     )
+;; CHECK-NEXT:     (else
+;; CHECK-NEXT:      (unreachable)
+;; CHECK-NEXT:     )
+;; CHECK-NEXT:    )
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:  )
+;; CHECK-NEXT: )
+
+;; CHECK:      (func $index_to_extern (type $5) (param $0 (ref null (shared i31))) (result externref)
+;; CHECK-NEXT:  (if (result externref)
+;; CHECK-NEXT:   (ref.is_null
+;; CHECK-NEXT:    (local.get $0)
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:   (then
+;; CHECK-NEXT:    (ref.null noextern)
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:   (else
+;; CHECK-NEXT:    (table.get $externs
+;; CHECK-NEXT:     (i31.get_u
+;; CHECK-NEXT:      (local.get $0)
+;; CHECK-NEXT:     )
+;; CHECK-NEXT:    )
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:  )
+;; CHECK-NEXT: )
+(module
+  ;; Non-nullable extern references entering and exiting via imports and exports.
+  (import "env" "import_nonnull_extern" (func $im (param (ref extern)) (result (ref extern))))
+
+  ;; CHECK:      (type $0 (func (param (ref (shared i31))) (result (ref (shared i31)))))
+
+  ;; CHECK:      (type $1 (func (param (ref extern)) (result (ref extern))))
+
+  ;; CHECK:      (type $2 (func (param externref) (result (ref null (shared i31)))))
+
+  ;; CHECK:      (type $3 (func (param (ref null (shared i31))) (result externref)))
+
+  ;; CHECK:      (import "env" "import_nonnull_extern" (func $im$import (type $1) (param (ref extern)) (result (ref extern))))
+
+  ;; CHECK:      (table $externs 0 externref)
+
+  ;; CHECK:      (export "export_nonnull_extern" (func $test$export))
+
+  ;; CHECK:      (func $im (type $0) (param $0 (ref (shared i31))) (result (ref (shared i31)))
+  ;; CHECK-NEXT:  (ref.as_non_null
+  ;; CHECK-NEXT:   (call $extern_to_index
+  ;; CHECK-NEXT:    (call $im$import
+  ;; CHECK-NEXT:     (ref.cast (ref extern)
+  ;; CHECK-NEXT:      (call $index_to_extern
+  ;; CHECK-NEXT:       (local.get $0)
+  ;; CHECK-NEXT:      )
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+
+  ;; CHECK:      (func $test (type $0) (param $e (ref (shared i31))) (result (ref (shared i31)))
+  ;; CHECK-NEXT:  (call $im
+  ;; CHECK-NEXT:   (local.get $e)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $test (export "export_nonnull_extern") (param $e (ref extern)) (result (ref extern))
+    (call $im (local.get $e))
+  )
+)
+
+;; CHECK:      (func $test$export (type $1) (param $0 (ref extern)) (result (ref extern))
+;; CHECK-NEXT:  (ref.cast (ref extern)
+;; CHECK-NEXT:   (call $index_to_extern
+;; CHECK-NEXT:    (call $test
+;; CHECK-NEXT:     (ref.as_non_null
+;; CHECK-NEXT:      (call $extern_to_index
+;; CHECK-NEXT:       (local.get $0)
+;; CHECK-NEXT:      )
+;; CHECK-NEXT:     )
+;; CHECK-NEXT:    )
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:  )
+;; CHECK-NEXT: )
+
+;; CHECK:      (func $extern_to_index (type $2) (param $0 externref) (result (ref null (shared i31)))
+;; CHECK-NEXT:  (local $1 i32)
+;; CHECK-NEXT:  (if (result (ref null (shared i31)))
+;; CHECK-NEXT:   (ref.is_null
+;; CHECK-NEXT:    (local.get $0)
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:   (then
+;; CHECK-NEXT:    (ref.null (shared none))
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:   (else
+;; CHECK-NEXT:    (if (result (ref (shared i31)))
+;; CHECK-NEXT:     (i32.ge_s
+;; CHECK-NEXT:      (local.tee $1
+;; CHECK-NEXT:       (table.grow $externs
+;; CHECK-NEXT:        (local.get $0)
+;; CHECK-NEXT:        (i32.const 1)
+;; CHECK-NEXT:       )
+;; CHECK-NEXT:      )
+;; CHECK-NEXT:      (i32.const 0)
+;; CHECK-NEXT:     )
+;; CHECK-NEXT:     (then
+;; CHECK-NEXT:      (ref.i31_shared
+;; CHECK-NEXT:       (local.get $1)
+;; CHECK-NEXT:      )
+;; CHECK-NEXT:     )
+;; CHECK-NEXT:     (else
+;; CHECK-NEXT:      (unreachable)
+;; CHECK-NEXT:     )
+;; CHECK-NEXT:    )
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:  )
+;; CHECK-NEXT: )
+
+;; CHECK:      (func $index_to_extern (type $3) (param $0 (ref null (shared i31))) (result externref)
+;; CHECK-NEXT:  (if (result externref)
+;; CHECK-NEXT:   (ref.is_null
+;; CHECK-NEXT:    (local.get $0)
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:   (then
+;; CHECK-NEXT:    (ref.null noextern)
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:   (else
+;; CHECK-NEXT:    (table.get $externs
+;; CHECK-NEXT:     (i31.get_u
+;; CHECK-NEXT:      (local.get $0)
+;; CHECK-NEXT:     )
+;; CHECK-NEXT:    )
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:  )
+;; CHECK-NEXT: )
+(module
+  ;; Function references (closed world) and shared extern references are NOT wrapped.
+  ;; CHECK:      (type $0 (func (param (ref null (shared i31))) (result (ref null (shared i31)))))
+
+  ;; CHECK:      (type $1 (func (param (ref null (shared extern))) (result (ref null (shared extern)))))
+
+  ;; CHECK:      (import "env" "import_func" (func $im_fn (type $0) (param (ref null (shared i31))) (result (ref null (shared i31)))))
+  (import "env" "import_func" (func $im_fn (param funcref) (result funcref)))
+  ;; CHECK:      (import "env" "import_shared_extern" (func $im_sh_ext (type $1) (param (ref null (shared extern))) (result (ref null (shared extern)))))
+  (import "env" "import_shared_extern" (func $im_sh_ext (param (ref null (shared extern))) (result (ref null (shared extern)))))
+
+  ;; CHECK:      (export "export_func" (func $test_func))
+
+  ;; CHECK:      (export "export_shared_extern" (func $test_shared_extern))
+
+  ;; CHECK:      (func $test_func (type $0) (param $f (ref null (shared i31))) (result (ref null (shared i31)))
+  ;; CHECK-NEXT:  (call $im_fn
+  ;; CHECK-NEXT:   (local.get $f)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $test_func (export "export_func") (param $f funcref) (result funcref)
+    (call $im_fn (local.get $f))
+  )
+
+  ;; CHECK:      (func $test_shared_extern (type $1) (param $e (ref null (shared extern))) (result (ref null (shared extern)))
+  ;; CHECK-NEXT:  (call $im_sh_ext
+  ;; CHECK-NEXT:   (local.get $e)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $test_shared_extern (export "export_shared_extern") (param $e (ref null (shared extern))) (result (ref null (shared extern)))
+    (call $im_sh_ext (local.get $e))
+  )
+)
+
+(module
+  ;; String references entering and exiting via imports and exports are wrapped with the extern table.
+  (import "env" "import_string" (func $im (param stringref (ref string)) (result stringref)))
+  ;; CHECK:      (type $0 (func (param (ref null (shared i31)) (ref (shared i31))) (result (ref null (shared i31)))))
+
+  ;; CHECK:      (type $1 (func (param (ref null (shared i31)) (ref (shared i31))) (result (ref (shared i31)))))
+
+  ;; CHECK:      (type $2 (func (param stringref (ref string)) (result stringref)))
+
+  ;; CHECK:      (type $3 (func (param stringref (ref string)) (result (ref string))))
+
+  ;; CHECK:      (type $4 (func (param externref) (result (ref null (shared i31)))))
+
+  ;; CHECK:      (type $5 (func (param (ref null (shared i31))) (result externref)))
+
+  ;; CHECK:      (import "env" "import_string" (func $im$import (type $2) (param stringref (ref string)) (result stringref)))
+
+  ;; CHECK:      (table $externs 0 externref)
+
+  ;; CHECK:      (export "export_string" (func $test$export))
+
+  ;; CHECK:      (func $im (type $0) (param $0 (ref null (shared i31))) (param $1 (ref (shared i31))) (result (ref null (shared i31)))
+  ;; CHECK-NEXT:  (call $extern_to_index
+  ;; CHECK-NEXT:   (call $im$import
+  ;; CHECK-NEXT:    (ref.cast stringref
+  ;; CHECK-NEXT:     (call $index_to_extern
+  ;; CHECK-NEXT:      (local.get $0)
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:    (ref.cast (ref string)
+  ;; CHECK-NEXT:     (call $index_to_extern
+  ;; CHECK-NEXT:      (local.get $1)
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+
+  ;; CHECK:      (func $test (type $1) (param $s (ref null (shared i31))) (param $s_nn (ref (shared i31))) (result (ref (shared i31)))
+  ;; CHECK-NEXT:  (drop
+  ;; CHECK-NEXT:   (call $im
+  ;; CHECK-NEXT:    (local.get $s)
+  ;; CHECK-NEXT:    (local.get $s_nn)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT:  (local.get $s_nn)
+  ;; CHECK-NEXT: )
+  (func $test (export "export_string") (param $s stringref) (param $s_nn (ref string)) (result (ref string))
+    (drop (call $im (local.get $s) (local.get $s_nn)))
+    (local.get $s_nn)
+  )
+)
+
+
+;; CHECK:      (func $test$export (type $3) (param $0 stringref) (param $1 (ref string)) (result (ref string))
+;; CHECK-NEXT:  (ref.cast (ref string)
+;; CHECK-NEXT:   (call $index_to_extern
+;; CHECK-NEXT:    (call $test
+;; CHECK-NEXT:     (call $extern_to_index
+;; CHECK-NEXT:      (local.get $0)
+;; CHECK-NEXT:     )
+;; CHECK-NEXT:     (ref.as_non_null
+;; CHECK-NEXT:      (call $extern_to_index
+;; CHECK-NEXT:       (local.get $1)
+;; CHECK-NEXT:      )
+;; CHECK-NEXT:     )
+;; CHECK-NEXT:    )
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:  )
+;; CHECK-NEXT: )
+
+;; CHECK:      (func $extern_to_index (type $4) (param $0 externref) (result (ref null (shared i31)))
+;; CHECK-NEXT:  (local $1 i32)
+;; CHECK-NEXT:  (if (result (ref null (shared i31)))
+;; CHECK-NEXT:   (ref.is_null
+;; CHECK-NEXT:    (local.get $0)
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:   (then
+;; CHECK-NEXT:    (ref.null (shared none))
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:   (else
+;; CHECK-NEXT:    (if (result (ref (shared i31)))
+;; CHECK-NEXT:     (i32.ge_s
+;; CHECK-NEXT:      (local.tee $1
+;; CHECK-NEXT:       (table.grow $externs
+;; CHECK-NEXT:        (local.get $0)
+;; CHECK-NEXT:        (i32.const 1)
+;; CHECK-NEXT:       )
+;; CHECK-NEXT:      )
+;; CHECK-NEXT:      (i32.const 0)
+;; CHECK-NEXT:     )
+;; CHECK-NEXT:     (then
+;; CHECK-NEXT:      (ref.i31_shared
+;; CHECK-NEXT:       (local.get $1)
+;; CHECK-NEXT:      )
+;; CHECK-NEXT:     )
+;; CHECK-NEXT:     (else
+;; CHECK-NEXT:      (unreachable)
+;; CHECK-NEXT:     )
+;; CHECK-NEXT:    )
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:  )
+;; CHECK-NEXT: )
+
+;; CHECK:      (func $index_to_extern (type $5) (param $0 (ref null (shared i31))) (result externref)
+;; CHECK-NEXT:  (if (result externref)
+;; CHECK-NEXT:   (ref.is_null
+;; CHECK-NEXT:    (local.get $0)
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:   (then
+;; CHECK-NEXT:    (ref.null noextern)
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:   (else
+;; CHECK-NEXT:    (table.get $externs
+;; CHECK-NEXT:     (i31.get_u
+;; CHECK-NEXT:      (local.get $0)
+;; CHECK-NEXT:     )
+;; CHECK-NEXT:    )
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:  )
+;; CHECK-NEXT: )
+(module
+  ;; Tuple results in import and export.
+  (import "env" "import_tuple" (func $im (param externref i32) (result externref (ref extern) i32)))
+
+  ;; CHECK:      (type $0 (func (param (ref null (shared i31)) i32) (result (ref null (shared i31)) (ref (shared i31)) i32)))
+
+  ;; CHECK:      (type $1 (func (param externref i32) (result externref (ref extern) i32)))
+
+  ;; CHECK:      (type $2 (func (param externref) (result (ref null (shared i31)))))
+
+  ;; CHECK:      (type $3 (func (param (ref null (shared i31))) (result externref)))
+
+  ;; CHECK:      (type $4 (func (result (ref null (shared i31)) (ref (shared i31)) i32)))
+
+  ;; CHECK:      (type $5 (func (result externref (ref extern) i32)))
+
+  ;; CHECK:      (import "env" "import_tuple" (func $im$import (type $1) (param externref i32) (result externref (ref extern) i32)))
+
+  ;; CHECK:      (table $externs 0 externref)
+
+  ;; CHECK:      (export "export_tuple" (func $test$export))
+
+  ;; CHECK:      (func $im (type $0) (param $0 (ref null (shared i31))) (param $1 i32) (result (ref null (shared i31)) (ref (shared i31)) i32)
+  ;; CHECK-NEXT:  (local $2 (tuple externref (ref extern) i32))
+  ;; CHECK-NEXT:  (local.set $2
+  ;; CHECK-NEXT:   (call $im$import
+  ;; CHECK-NEXT:    (call $index_to_extern
+  ;; CHECK-NEXT:     (local.get $0)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:    (local.get $1)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT:  (tuple.make 3
+  ;; CHECK-NEXT:   (call $extern_to_index
+  ;; CHECK-NEXT:    (tuple.extract 3 0
+  ;; CHECK-NEXT:     (local.get $2)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (ref.as_non_null
+  ;; CHECK-NEXT:    (call $extern_to_index
+  ;; CHECK-NEXT:     (tuple.extract 3 1
+  ;; CHECK-NEXT:      (local.get $2)
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (tuple.extract 3 2
+  ;; CHECK-NEXT:    (local.get $2)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+
+  ;; CHECK:      (func $test (type $0) (param $e (ref null (shared i31))) (param $i i32) (result (ref null (shared i31)) (ref (shared i31)) i32)
+  ;; CHECK-NEXT:  (call $im
+  ;; CHECK-NEXT:   (local.get $e)
+  ;; CHECK-NEXT:   (local.get $i)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $test (export "export_tuple") (param $e externref) (param $i i32) (result externref (ref extern) i32)
+    (call $im (local.get $e) (local.get $i))
+  )
+)
+
+;; CHECK:      (func $test$export (type $1) (param $0 externref) (param $1 i32) (result externref (ref extern) i32)
+;; CHECK-NEXT:  (local $2 (tuple (ref null (shared i31)) (ref (shared i31)) i32))
+;; CHECK-NEXT:  (local.set $2
+;; CHECK-NEXT:   (call $test
+;; CHECK-NEXT:    (call $extern_to_index
+;; CHECK-NEXT:     (local.get $0)
+;; CHECK-NEXT:    )
+;; CHECK-NEXT:    (local.get $1)
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:  )
+;; CHECK-NEXT:  (tuple.make 3
+;; CHECK-NEXT:   (call $index_to_extern
+;; CHECK-NEXT:    (tuple.extract 3 0
+;; CHECK-NEXT:     (local.get $2)
+;; CHECK-NEXT:    )
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:   (ref.cast (ref extern)
+;; CHECK-NEXT:    (call $index_to_extern
+;; CHECK-NEXT:     (tuple.extract 3 1
+;; CHECK-NEXT:      (local.get $2)
+;; CHECK-NEXT:     )
+;; CHECK-NEXT:    )
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:   (tuple.extract 3 2
+;; CHECK-NEXT:    (local.get $2)
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:  )
+;; CHECK-NEXT: )
+
+;; CHECK:      (func $extern_to_index (type $2) (param $0 externref) (result (ref null (shared i31)))
+;; CHECK-NEXT:  (local $1 i32)
+;; CHECK-NEXT:  (if (result (ref null (shared i31)))
+;; CHECK-NEXT:   (ref.is_null
+;; CHECK-NEXT:    (local.get $0)
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:   (then
+;; CHECK-NEXT:    (ref.null (shared none))
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:   (else
+;; CHECK-NEXT:    (if (result (ref (shared i31)))
+;; CHECK-NEXT:     (i32.ge_s
+;; CHECK-NEXT:      (local.tee $1
+;; CHECK-NEXT:       (table.grow $externs
+;; CHECK-NEXT:        (local.get $0)
+;; CHECK-NEXT:        (i32.const 1)
+;; CHECK-NEXT:       )
+;; CHECK-NEXT:      )
+;; CHECK-NEXT:      (i32.const 0)
+;; CHECK-NEXT:     )
+;; CHECK-NEXT:     (then
+;; CHECK-NEXT:      (ref.i31_shared
+;; CHECK-NEXT:       (local.get $1)
+;; CHECK-NEXT:      )
+;; CHECK-NEXT:     )
+;; CHECK-NEXT:     (else
+;; CHECK-NEXT:      (unreachable)
+;; CHECK-NEXT:     )
+;; CHECK-NEXT:    )
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:  )
+;; CHECK-NEXT: )
+
+;; CHECK:      (func $index_to_extern (type $3) (param $0 (ref null (shared i31))) (result externref)
+;; CHECK-NEXT:  (if (result externref)
+;; CHECK-NEXT:   (ref.is_null
+;; CHECK-NEXT:    (local.get $0)
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:   (then
+;; CHECK-NEXT:    (ref.null noextern)
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:   (else
+;; CHECK-NEXT:    (table.get $externs
+;; CHECK-NEXT:     (i31.get_u
+;; CHECK-NEXT:      (local.get $0)
+;; CHECK-NEXT:     )
+;; CHECK-NEXT:    )
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:  )
+;; CHECK-NEXT: )
+(module
+  ;; Convert between extern and any (nullable and non-nullable)
+  ;; CHECK:      (type $0 (func (param (ref null (shared i31))) (result (ref null (shared any)))))
+
+  ;; CHECK:      (type $1 (func (param (ref (shared i31))) (result (ref (shared any)))))
+
+  ;; CHECK:      (type $2 (func (param (ref null (shared any))) (result (ref null (shared i31)))))
+
+  ;; CHECK:      (type $3 (func (param (ref (shared any))) (result (ref (shared i31)))))
+
+  ;; CHECK:      (type $4 (func (param externref) (result (ref null (shared i31)))))
+
+  ;; CHECK:      (type $5 (func (param (ref null (shared i31))) (result externref)))
+
+  ;; CHECK:      (type $6 (func (param (ref null (shared any))) (result externref)))
+
+  ;; CHECK:      (type $7 (func (param externref) (result (ref null (shared any)))))
+
+  ;; CHECK:      (import "env" "any_to_extern" (func $any_to_extern (exact (type $6) (param (ref null (shared any))) (result externref))))
+
+  ;; CHECK:      (import "env" "extern_to_any" (func $extern_to_any (exact (type $7) (param externref) (result (ref null (shared any))))))
+
+  ;; CHECK:      (table $externs 0 externref)
+
+  ;; CHECK:      (func $any_convert_extern_nullable (type $0) (param $e (ref null (shared i31))) (result (ref null (shared any)))
+  ;; CHECK-NEXT:  (call $extern_to_any
+  ;; CHECK-NEXT:   (call $index_to_extern
+  ;; CHECK-NEXT:    (local.get $e)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $any_convert_extern_nullable (param $e externref) (result anyref)
+    (any.convert_extern (local.get $e))
+  )
+
+  ;; CHECK:      (func $any_convert_extern_non_nullable (type $1) (param $e (ref (shared i31))) (result (ref (shared any)))
+  ;; CHECK-NEXT:  (ref.as_non_null
+  ;; CHECK-NEXT:   (call $extern_to_any
+  ;; CHECK-NEXT:    (ref.cast (ref extern)
+  ;; CHECK-NEXT:     (call $index_to_extern
+  ;; CHECK-NEXT:      (local.get $e)
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $any_convert_extern_non_nullable (param $e (ref extern)) (result (ref any))
+    (any.convert_extern (local.get $e))
+  )
+
+  ;; CHECK:      (func $extern_convert_any_nullable (type $2) (param $a (ref null (shared any))) (result (ref null (shared i31)))
+  ;; CHECK-NEXT:  (call $extern_to_index
+  ;; CHECK-NEXT:   (call $any_to_extern
+  ;; CHECK-NEXT:    (local.get $a)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $extern_convert_any_nullable (param $a anyref) (result externref)
+    (extern.convert_any (local.get $a))
+  )
+
+  ;; CHECK:      (func $extern_convert_any_non_nullable (type $3) (param $a (ref (shared any))) (result (ref (shared i31)))
+  ;; CHECK-NEXT:  (ref.as_non_null
+  ;; CHECK-NEXT:   (call $extern_to_index
+  ;; CHECK-NEXT:    (call $any_to_extern
+  ;; CHECK-NEXT:     (local.get $a)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $extern_convert_any_non_nullable (param $a (ref any)) (result (ref extern))
+    (extern.convert_any (local.get $a))
+  )
+)
+
+;; CHECK:      (func $extern_to_index (type $4) (param $0 externref) (result (ref null (shared i31)))
+;; CHECK-NEXT:  (local $1 i32)
+;; CHECK-NEXT:  (if (result (ref null (shared i31)))
+;; CHECK-NEXT:   (ref.is_null
+;; CHECK-NEXT:    (local.get $0)
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:   (then
+;; CHECK-NEXT:    (ref.null (shared none))
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:   (else
+;; CHECK-NEXT:    (if (result (ref (shared i31)))
+;; CHECK-NEXT:     (i32.ge_s
+;; CHECK-NEXT:      (local.tee $1
+;; CHECK-NEXT:       (table.grow $externs
+;; CHECK-NEXT:        (local.get $0)
+;; CHECK-NEXT:        (i32.const 1)
+;; CHECK-NEXT:       )
+;; CHECK-NEXT:      )
+;; CHECK-NEXT:      (i32.const 0)
+;; CHECK-NEXT:     )
+;; CHECK-NEXT:     (then
+;; CHECK-NEXT:      (ref.i31_shared
+;; CHECK-NEXT:       (local.get $1)
+;; CHECK-NEXT:      )
+;; CHECK-NEXT:     )
+;; CHECK-NEXT:     (else
+;; CHECK-NEXT:      (unreachable)
+;; CHECK-NEXT:     )
+;; CHECK-NEXT:    )
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:  )
+;; CHECK-NEXT: )
+
+;; CHECK:      (func $index_to_extern (type $5) (param $0 (ref null (shared i31))) (result externref)
+;; CHECK-NEXT:  (if (result externref)
+;; CHECK-NEXT:   (ref.is_null
+;; CHECK-NEXT:    (local.get $0)
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:   (then
+;; CHECK-NEXT:    (ref.null noextern)
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:   (else
+;; CHECK-NEXT:    (table.get $externs
+;; CHECK-NEXT:     (i31.get_u
+;; CHECK-NEXT:      (local.get $0)
+;; CHECK-NEXT:     )
+;; CHECK-NEXT:    )
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:  )
+;; CHECK-NEXT: )
+(module
+  ;; Re-export an imported function with externrefs.
+  (import "env" "import_and_export" (func $im (param externref) (result externref)))
+  (export "export_import" (func $im))
+)
+
+;; CHECK:      (type $0 (func (param externref) (result externref)))
+
+;; CHECK:      (type $1 (func (param (ref null (shared i31))) (result (ref null (shared i31)))))
+
+;; CHECK:      (type $2 (func (param externref) (result (ref null (shared i31)))))
+
+;; CHECK:      (type $3 (func (param (ref null (shared i31))) (result externref)))
+
+;; CHECK:      (import "env" "import_and_export" (func $im$import (type $0) (param externref) (result externref)))
+
+;; CHECK:      (table $externs 0 externref)
+
+;; CHECK:      (export "export_import" (func $im$export))
+
+;; CHECK:      (func $im (type $1) (param $0 (ref null (shared i31))) (result (ref null (shared i31)))
+;; CHECK-NEXT:  (call $extern_to_index
+;; CHECK-NEXT:   (call $im$import
+;; CHECK-NEXT:    (call $index_to_extern
+;; CHECK-NEXT:     (local.get $0)
+;; CHECK-NEXT:    )
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:  )
+;; CHECK-NEXT: )
+
+;; CHECK:      (func $im$export (type $0) (param $0 externref) (result externref)
+;; CHECK-NEXT:  (call $index_to_extern
+;; CHECK-NEXT:   (call $im
+;; CHECK-NEXT:    (call $extern_to_index
+;; CHECK-NEXT:     (local.get $0)
+;; CHECK-NEXT:    )
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:  )
+;; CHECK-NEXT: )
+
+;; CHECK:      (func $extern_to_index (type $2) (param $0 externref) (result (ref null (shared i31)))
+;; CHECK-NEXT:  (local $1 i32)
+;; CHECK-NEXT:  (if (result (ref null (shared i31)))
+;; CHECK-NEXT:   (ref.is_null
+;; CHECK-NEXT:    (local.get $0)
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:   (then
+;; CHECK-NEXT:    (ref.null (shared none))
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:   (else
+;; CHECK-NEXT:    (if (result (ref (shared i31)))
+;; CHECK-NEXT:     (i32.ge_s
+;; CHECK-NEXT:      (local.tee $1
+;; CHECK-NEXT:       (table.grow $externs
+;; CHECK-NEXT:        (local.get $0)
+;; CHECK-NEXT:        (i32.const 1)
+;; CHECK-NEXT:       )
+;; CHECK-NEXT:      )
+;; CHECK-NEXT:      (i32.const 0)
+;; CHECK-NEXT:     )
+;; CHECK-NEXT:     (then
+;; CHECK-NEXT:      (ref.i31_shared
+;; CHECK-NEXT:       (local.get $1)
+;; CHECK-NEXT:      )
+;; CHECK-NEXT:     )
+;; CHECK-NEXT:     (else
+;; CHECK-NEXT:      (unreachable)
+;; CHECK-NEXT:     )
+;; CHECK-NEXT:    )
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:  )
+;; CHECK-NEXT: )
+
+;; CHECK:      (func $index_to_extern (type $3) (param $0 (ref null (shared i31))) (result externref)
+;; CHECK-NEXT:  (if (result externref)
+;; CHECK-NEXT:   (ref.is_null
+;; CHECK-NEXT:    (local.get $0)
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:   (then
+;; CHECK-NEXT:    (ref.null noextern)
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:   (else
+;; CHECK-NEXT:    (table.get $externs
+;; CHECK-NEXT:     (i31.get_u
+;; CHECK-NEXT:      (local.get $0)
+;; CHECK-NEXT:     )
+;; CHECK-NEXT:    )
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:  )
+;; CHECK-NEXT: )
+(module
+  ;; Multiple exports of the same function are deduplicated.
+  ;; CHECK:      (type $0 (func (param (ref null (shared i31))) (result (ref null (shared i31)))))
+
+  ;; CHECK:      (type $1 (func (param externref) (result externref)))
+
+  ;; CHECK:      (type $2 (func (param externref) (result (ref null (shared i31)))))
+
+  ;; CHECK:      (type $3 (func (param (ref null (shared i31))) (result externref)))
+
+  ;; CHECK:      (table $externs 0 externref)
+
+  ;; CHECK:      (export "exp1" (func $multi$export))
+
+  ;; CHECK:      (export "exp2" (func $multi$export))
+
+  ;; CHECK:      (func $multi (type $0) (param $0 (ref null (shared i31))) (result (ref null (shared i31)))
+  ;; CHECK-NEXT:  (local.get $0)
+  ;; CHECK-NEXT: )
+  (func $multi (export "exp1") (export "exp2") (param externref) (result externref)
+    (local.get 0)
+  )
+)
+
+;; CHECK:      (func $multi$export (type $1) (param $0 externref) (result externref)
+;; CHECK-NEXT:  (call $index_to_extern
+;; CHECK-NEXT:   (call $multi
+;; CHECK-NEXT:    (call $extern_to_index
+;; CHECK-NEXT:     (local.get $0)
+;; CHECK-NEXT:    )
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:  )
+;; CHECK-NEXT: )
+
+;; CHECK:      (func $extern_to_index (type $2) (param $0 externref) (result (ref null (shared i31)))
+;; CHECK-NEXT:  (local $1 i32)
+;; CHECK-NEXT:  (if (result (ref null (shared i31)))
+;; CHECK-NEXT:   (ref.is_null
+;; CHECK-NEXT:    (local.get $0)
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:   (then
+;; CHECK-NEXT:    (ref.null (shared none))
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:   (else
+;; CHECK-NEXT:    (if (result (ref (shared i31)))
+;; CHECK-NEXT:     (i32.ge_s
+;; CHECK-NEXT:      (local.tee $1
+;; CHECK-NEXT:       (table.grow $externs
+;; CHECK-NEXT:        (local.get $0)
+;; CHECK-NEXT:        (i32.const 1)
+;; CHECK-NEXT:       )
+;; CHECK-NEXT:      )
+;; CHECK-NEXT:      (i32.const 0)
+;; CHECK-NEXT:     )
+;; CHECK-NEXT:     (then
+;; CHECK-NEXT:      (ref.i31_shared
+;; CHECK-NEXT:       (local.get $1)
+;; CHECK-NEXT:      )
+;; CHECK-NEXT:     )
+;; CHECK-NEXT:     (else
+;; CHECK-NEXT:      (unreachable)
+;; CHECK-NEXT:     )
+;; CHECK-NEXT:    )
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:  )
+;; CHECK-NEXT: )
+
+;; CHECK:      (func $index_to_extern (type $3) (param $0 (ref null (shared i31))) (result externref)
+;; CHECK-NEXT:  (if (result externref)
+;; CHECK-NEXT:   (ref.is_null
+;; CHECK-NEXT:    (local.get $0)
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:   (then
+;; CHECK-NEXT:    (ref.null noextern)
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:   (else
+;; CHECK-NEXT:    (table.get $externs
+;; CHECK-NEXT:     (i31.get_u
+;; CHECK-NEXT:      (local.get $0)
+;; CHECK-NEXT:     )
+;; CHECK-NEXT:    )
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:  )
+;; CHECK-NEXT: )
+(module
+  ;; Tuple result without externrefs should not unpack and repack.
+  (import "env" "import_no_ext_tuple" (func $im_tuple (param externref) (result i32 i64)))
+  ;; CHECK:      (type $0 (func (param (ref null (shared i31))) (result i32 i64)))
+
+  ;; CHECK:      (type $1 (func (param externref) (result i32 i64)))
+
+  ;; CHECK:      (type $2 (func (param externref) (result (ref null (shared i31)))))
+
+  ;; CHECK:      (type $3 (func (param (ref null (shared i31))) (result externref)))
+
+  ;; CHECK:      (import "env" "import_no_ext_tuple" (func $im_tuple$import (type $1) (param externref) (result i32 i64)))
+
+  ;; CHECK:      (table $externs 0 externref)
+
+  ;; CHECK:      (export "export_no_ext_tuple" (func $test_no_ext_tuple$export))
+
+  ;; CHECK:      (func $im_tuple (type $0) (param $0 (ref null (shared i31))) (result i32 i64)
+  ;; CHECK-NEXT:  (call $im_tuple$import
+  ;; CHECK-NEXT:   (call $index_to_extern
+  ;; CHECK-NEXT:    (local.get $0)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+
+  ;; CHECK:      (func $test_no_ext_tuple (type $0) (param $0 (ref null (shared i31))) (result i32 i64)
+  ;; CHECK-NEXT:  (call $im_tuple
+  ;; CHECK-NEXT:   (local.get $0)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $test_no_ext_tuple (export "export_no_ext_tuple") (param externref) (result i32 i64)
+    (call $im_tuple (local.get 0))
+  )
+)
+
+;; CHECK:      (func $test_no_ext_tuple$export (type $1) (param $0 externref) (result i32 i64)
+;; CHECK-NEXT:  (call $test_no_ext_tuple
+;; CHECK-NEXT:   (call $extern_to_index
+;; CHECK-NEXT:    (local.get $0)
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:  )
+;; CHECK-NEXT: )
+
+;; CHECK:      (func $extern_to_index (type $2) (param $0 externref) (result (ref null (shared i31)))
+;; CHECK-NEXT:  (local $1 i32)
+;; CHECK-NEXT:  (if (result (ref null (shared i31)))
+;; CHECK-NEXT:   (ref.is_null
+;; CHECK-NEXT:    (local.get $0)
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:   (then
+;; CHECK-NEXT:    (ref.null (shared none))
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:   (else
+;; CHECK-NEXT:    (if (result (ref (shared i31)))
+;; CHECK-NEXT:     (i32.ge_s
+;; CHECK-NEXT:      (local.tee $1
+;; CHECK-NEXT:       (table.grow $externs
+;; CHECK-NEXT:        (local.get $0)
+;; CHECK-NEXT:        (i32.const 1)
+;; CHECK-NEXT:       )
+;; CHECK-NEXT:      )
+;; CHECK-NEXT:      (i32.const 0)
+;; CHECK-NEXT:     )
+;; CHECK-NEXT:     (then
+;; CHECK-NEXT:      (ref.i31_shared
+;; CHECK-NEXT:       (local.get $1)
+;; CHECK-NEXT:      )
+;; CHECK-NEXT:     )
+;; CHECK-NEXT:     (else
+;; CHECK-NEXT:      (unreachable)
+;; CHECK-NEXT:     )
+;; CHECK-NEXT:    )
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:  )
+;; CHECK-NEXT: )
+
+;; CHECK:      (func $index_to_extern (type $3) (param $0 (ref null (shared i31))) (result externref)
+;; CHECK-NEXT:  (if (result externref)
+;; CHECK-NEXT:   (ref.is_null
+;; CHECK-NEXT:    (local.get $0)
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:   (then
+;; CHECK-NEXT:    (ref.null noextern)
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:   (else
+;; CHECK-NEXT:    (table.get $externs
+;; CHECK-NEXT:     (i31.get_u
+;; CHECK-NEXT:      (local.get $0)
+;; CHECK-NEXT:     )
+;; CHECK-NEXT:    )
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:  )
+;; CHECK-NEXT: )
+(module
+  ;; Mixed struct and externref at boundary.
+  ;; CHECK:      (type $struct (shared (struct (field (mut i32)))))
+  (type $struct (struct (field (mut i32))))
+  (import "env" "import_mixed" (func $im_mixed (param (ref $struct) externref) (result (ref $struct) externref)))
+  ;; CHECK:      (type $1 (func (param (ref $struct) (ref null (shared i31))) (result (ref $struct) (ref null (shared i31)))))
+
+  ;; CHECK:      (type $2 (func (param (ref $struct) externref) (result (ref $struct) externref)))
+
+  ;; CHECK:      (type $3 (func (param externref) (result (ref null (shared i31)))))
+
+  ;; CHECK:      (type $4 (func (param (ref null (shared i31))) (result externref)))
+
+  ;; CHECK:      (type $5 (func (result (ref $struct) (ref null (shared i31)))))
+
+  ;; CHECK:      (type $6 (func (result (ref $struct) externref)))
+
+  ;; CHECK:      (import "env" "import_mixed" (func $im_mixed$import (type $2) (param (ref $struct) externref) (result (ref $struct) externref)))
+
+  ;; CHECK:      (table $externs 0 externref)
+
+  ;; CHECK:      (export "export_mixed" (func $test_mixed$export))
+
+  ;; CHECK:      (func $im_mixed (type $1) (param $0 (ref $struct)) (param $1 (ref null (shared i31))) (result (ref $struct) (ref null (shared i31)))
+  ;; CHECK-NEXT:  (local $2 (tuple (ref $struct) externref))
+  ;; CHECK-NEXT:  (local.set $2
+  ;; CHECK-NEXT:   (call $im_mixed$import
+  ;; CHECK-NEXT:    (local.get $0)
+  ;; CHECK-NEXT:    (call $index_to_extern
+  ;; CHECK-NEXT:     (local.get $1)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT:  (tuple.make 2
+  ;; CHECK-NEXT:   (tuple.extract 2 0
+  ;; CHECK-NEXT:    (local.get $2)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (call $extern_to_index
+  ;; CHECK-NEXT:    (tuple.extract 2 1
+  ;; CHECK-NEXT:     (local.get $2)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+
+  ;; CHECK:      (func $test_mixed (type $1) (param $0 (ref $struct)) (param $1 (ref null (shared i31))) (result (ref $struct) (ref null (shared i31)))
+  ;; CHECK-NEXT:  (call $im_mixed
+  ;; CHECK-NEXT:   (local.get $0)
+  ;; CHECK-NEXT:   (local.get $1)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $test_mixed (export "export_mixed") (param (ref $struct) externref) (result (ref $struct) externref)
+    (call $im_mixed (local.get 0) (local.get 1))
+  )
+)
+;; CHECK:      (func $test_mixed$export (type $2) (param $0 (ref $struct)) (param $1 externref) (result (ref $struct) externref)
+;; CHECK-NEXT:  (local $2 (tuple (ref $struct) (ref null (shared i31))))
+;; CHECK-NEXT:  (local.set $2
+;; CHECK-NEXT:   (call $test_mixed
+;; CHECK-NEXT:    (local.get $0)
+;; CHECK-NEXT:    (call $extern_to_index
+;; CHECK-NEXT:     (local.get $1)
+;; CHECK-NEXT:    )
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:  )
+;; CHECK-NEXT:  (tuple.make 2
+;; CHECK-NEXT:   (tuple.extract 2 0
+;; CHECK-NEXT:    (local.get $2)
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:   (call $index_to_extern
+;; CHECK-NEXT:    (tuple.extract 2 1
+;; CHECK-NEXT:     (local.get $2)
+;; CHECK-NEXT:    )
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:  )
+;; CHECK-NEXT: )
+
+;; CHECK:      (func $extern_to_index (type $3) (param $0 externref) (result (ref null (shared i31)))
+;; CHECK-NEXT:  (local $1 i32)
+;; CHECK-NEXT:  (if (result (ref null (shared i31)))
+;; CHECK-NEXT:   (ref.is_null
+;; CHECK-NEXT:    (local.get $0)
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:   (then
+;; CHECK-NEXT:    (ref.null (shared none))
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:   (else
+;; CHECK-NEXT:    (if (result (ref (shared i31)))
+;; CHECK-NEXT:     (i32.ge_s
+;; CHECK-NEXT:      (local.tee $1
+;; CHECK-NEXT:       (table.grow $externs
+;; CHECK-NEXT:        (local.get $0)
+;; CHECK-NEXT:        (i32.const 1)
+;; CHECK-NEXT:       )
+;; CHECK-NEXT:      )
+;; CHECK-NEXT:      (i32.const 0)
+;; CHECK-NEXT:     )
+;; CHECK-NEXT:     (then
+;; CHECK-NEXT:      (ref.i31_shared
+;; CHECK-NEXT:       (local.get $1)
+;; CHECK-NEXT:      )
+;; CHECK-NEXT:     )
+;; CHECK-NEXT:     (else
+;; CHECK-NEXT:      (unreachable)
+;; CHECK-NEXT:     )
+;; CHECK-NEXT:    )
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:  )
+;; CHECK-NEXT: )
+
+;; CHECK:      (func $index_to_extern (type $4) (param $0 (ref null (shared i31))) (result externref)
+;; CHECK-NEXT:  (if (result externref)
+;; CHECK-NEXT:   (ref.is_null
+;; CHECK-NEXT:    (local.get $0)
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:   (then
+;; CHECK-NEXT:    (ref.null noextern)
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:   (else
+;; CHECK-NEXT:    (table.get $externs
+;; CHECK-NEXT:     (i31.get_u
+;; CHECK-NEXT:      (local.get $0)
+;; CHECK-NEXT:     )
+;; CHECK-NEXT:    )
+;; CHECK-NEXT:   )
+;; CHECK-NEXT:  )
+;; CHECK-NEXT: )
diff --git a/test/lit/passes/once-reduction.wast b/test/lit/passes/once-reduction.wast
index f8a6a1cee67..4cf6fd9b81e 100644
--- a/test/lit/passes/once-reduction.wast
+++ b/test/lit/passes/once-reduction.wast
@@ -966,7 +966,7 @@
   )
 )
 
-;; Corner case: Optimization opportunties in unreachable code (which we can
+;; Corner case: Optimization opportunities in unreachable code (which we can
 ;; ignore, but should not error on).
 (module
   ;; CHECK:      (type $0 (func))
diff --git a/test/lit/passes/optimize-casts.wast b/test/lit/passes/optimize-casts.wast
index 0719cbd91f9..1247872fe41 100644
--- a/test/lit/passes/optimize-casts.wast
+++ b/test/lit/passes/optimize-casts.wast
@@ -722,7 +722,7 @@
   (func $move-cast-5 (param $x (ref struct))
     (drop
       ;; The first location is already the most refined cast, so nothing will be moved up.
-      ;; (But we will save the cast to a local and re-use it below.)
+      ;; (But we will save the cast to a local and reuse it below.)
       (ref.cast (ref $B)
         (local.get $x)
       )
diff --git a/test/lit/passes/optimize-instructions-atomics.wast b/test/lit/passes/optimize-instructions-atomics.wast
index e59c6a4e79b..3086fe26896 100644
--- a/test/lit/passes/optimize-instructions-atomics.wast
+++ b/test/lit/passes/optimize-instructions-atomics.wast
@@ -91,4 +91,152 @@
   ;; skips
   (drop (i64.extend_i32_s (i32.atomic.load (local.get $x))))
  )
+
+ ;; CHECK:      (func $select-atomic-rmw (result i32)
+ ;; CHECK-NEXT:  (select
+ ;; CHECK-NEXT:   (i32.atomic.rmw16.xchg_u
+ ;; CHECK-NEXT:    (i32.const 0)
+ ;; CHECK-NEXT:    (i32.const 1)
+ ;; CHECK-NEXT:   )
+ ;; CHECK-NEXT:   (i32.atomic.rmw16.xchg_u
+ ;; CHECK-NEXT:    (i32.const 0)
+ ;; CHECK-NEXT:    (i32.const 1)
+ ;; CHECK-NEXT:   )
+ ;; CHECK-NEXT:   (i32.const 1)
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT: )
+ (func $select-atomic-rmw (result i32)
+  ;; The first rmw here influences the second, and we need to return the result
+  ;; of the first, which means we need a temp local. We avoid adding one and do
+  ;; not optimize here. Other instructions are tested in the functions below.
+  (select
+   (i32.atomic.rmw16.xchg_u
+    (i32.const 0)
+    (i32.const 1)
+   )
+   (i32.atomic.rmw16.xchg_u
+    (i32.const 0)
+    (i32.const 1)
+   )
+   (i32.const 1)
+  )
+ )
+
+ ;; CHECK:      (func $select-atomic-cmpxchg (result i32)
+ ;; CHECK-NEXT:  (select
+ ;; CHECK-NEXT:   (i32.atomic.rmw.cmpxchg
+ ;; CHECK-NEXT:    (i32.const 0)
+ ;; CHECK-NEXT:    (i32.const 1)
+ ;; CHECK-NEXT:    (i32.const 2)
+ ;; CHECK-NEXT:   )
+ ;; CHECK-NEXT:   (i32.atomic.rmw.cmpxchg
+ ;; CHECK-NEXT:    (i32.const 0)
+ ;; CHECK-NEXT:    (i32.const 1)
+ ;; CHECK-NEXT:    (i32.const 2)
+ ;; CHECK-NEXT:   )
+ ;; CHECK-NEXT:   (i32.const 1)
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT: )
+ (func $select-atomic-cmpxchg (result i32)
+  (select
+   (i32.atomic.rmw.cmpxchg
+    (i32.const 0)
+    (i32.const 1)
+    (i32.const 2)
+   )
+   (i32.atomic.rmw.cmpxchg
+    (i32.const 0)
+    (i32.const 1)
+    (i32.const 2)
+   )
+   (i32.const 1)
+  )
+ )
+
+ ;; CHECK:      (func $select-atomic-wait (result i32)
+ ;; CHECK-NEXT:  (select
+ ;; CHECK-NEXT:   (memory.atomic.wait32
+ ;; CHECK-NEXT:    (i32.const 0)
+ ;; CHECK-NEXT:    (i32.const 1)
+ ;; CHECK-NEXT:    (i64.const 2)
+ ;; CHECK-NEXT:   )
+ ;; CHECK-NEXT:   (memory.atomic.wait32
+ ;; CHECK-NEXT:    (i32.const 0)
+ ;; CHECK-NEXT:    (i32.const 1)
+ ;; CHECK-NEXT:    (i64.const 2)
+ ;; CHECK-NEXT:   )
+ ;; CHECK-NEXT:   (i32.const 1)
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT: )
+ (func $select-atomic-wait (result i32)
+  (select
+   (memory.atomic.wait32
+    (i32.const 0)
+    (i32.const 1)
+    (i64.const 2)
+   )
+   (memory.atomic.wait32
+    (i32.const 0)
+    (i32.const 1)
+    (i64.const 2)
+   )
+   (i32.const 1)
+  )
+ )
+
+ ;; CHECK:      (func $select-atomic-notify (result i32)
+ ;; CHECK-NEXT:  (select
+ ;; CHECK-NEXT:   (memory.atomic.notify
+ ;; CHECK-NEXT:    (i32.const 0)
+ ;; CHECK-NEXT:    (i32.const 1)
+ ;; CHECK-NEXT:   )
+ ;; CHECK-NEXT:   (memory.atomic.notify
+ ;; CHECK-NEXT:    (i32.const 0)
+ ;; CHECK-NEXT:    (i32.const 1)
+ ;; CHECK-NEXT:   )
+ ;; CHECK-NEXT:   (i32.const 1)
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT: )
+ (func $select-atomic-notify (result i32)
+  (select
+   (memory.atomic.notify
+    (i32.const 0)
+    (i32.const 1)
+   )
+   (memory.atomic.notify
+    (i32.const 0)
+    (i32.const 1)
+   )
+   (i32.const 1)
+  )
+ )
+
+ ;; CHECK:      (func $select-atomic-load (result i32)
+ ;; CHECK-NEXT:  (drop
+ ;; CHECK-NEXT:   (i32.atomic.load
+ ;; CHECK-NEXT:    (i32.const 0)
+ ;; CHECK-NEXT:   )
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT:  (drop
+ ;; CHECK-NEXT:   (i32.const 1)
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT:  (i32.atomic.load
+ ;; CHECK-NEXT:   (i32.const 0)
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT: )
+ (func $select-atomic-load (result i32)
+  ;; For comparison with above, when the instruction is not generative, we can
+  ;; optimize: the two atomic loads must return the same thing, so we drop the
+  ;; first and return the second (even though the first is what the select
+  ;; returns).
+  (select
+   (i32.atomic.load
+    (i32.const 0)
+   )
+   (i32.atomic.load
+    (i32.const 0)
+   )
+   (i32.const 1)
+  )
+ )
 )
diff --git a/test/lit/passes/optimize-instructions-desc.wast b/test/lit/passes/optimize-instructions-desc.wast
index c06764dccb1..7cb5aaf0e2b 100644
--- a/test/lit/passes/optimize-instructions-desc.wast
+++ b/test/lit/passes/optimize-instructions-desc.wast
@@ -37,14 +37,14 @@
     (type $struct-i32.desc (describes $struct-i32) (struct))
   )
 
-  ;; CHECK:      (import "" "" (func $effect (type $4)))
-  ;; NTRAP:      (import "" "" (func $effect (type $4)))
+  ;; CHECK:      (import "" "" (func $effect (type $5)))
+  ;; NTRAP:      (import "" "" (func $effect (type $5)))
   (import "" "" (func $effect))
 
-  ;; CHECK:      (func $trap-null-desc (type $10) (result (ref (exact $struct)))
+  ;; CHECK:      (func $trap-null-desc (type $11) (result (ref (exact $struct)))
   ;; CHECK-NEXT:  (unreachable)
   ;; CHECK-NEXT: )
-  ;; NTRAP:      (func $trap-null-desc (type $10) (result (ref (exact $struct)))
+  ;; NTRAP:      (func $trap-null-desc (type $11) (result (ref (exact $struct)))
   ;; NTRAP-NEXT:  (unreachable)
   ;; NTRAP-NEXT: )
   (func $trap-null-desc (result (ref (exact $struct)))
@@ -53,7 +53,7 @@
     )
   )
 
-  ;; CHECK:      (func $trap-null-desc-fallthrough (type $10) (result (ref (exact $struct)))
+  ;; CHECK:      (func $trap-null-desc-fallthrough (type $11) (result (ref (exact $struct)))
   ;; CHECK-NEXT:  (local $desc (ref null (exact $desc)))
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (local.tee $desc
@@ -62,7 +62,7 @@
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (unreachable)
   ;; CHECK-NEXT: )
-  ;; NTRAP:      (func $trap-null-desc-fallthrough (type $10) (result (ref (exact $struct)))
+  ;; NTRAP:      (func $trap-null-desc-fallthrough (type $11) (result (ref (exact $struct)))
   ;; NTRAP-NEXT:  (local $desc (ref null (exact $desc)))
   ;; NTRAP-NEXT:  (drop
   ;; NTRAP-NEXT:   (local.tee $desc
@@ -80,12 +80,12 @@
     )
   )
 
-  ;; CHECK:      (func $nonnull-cast-desc-eq (type $19) (param $desc (ref null (exact $desc))) (result (ref (exact $struct)))
+  ;; CHECK:      (func $nonnull-cast-desc-eq (type $20) (param $desc (ref null (exact $desc))) (result (ref (exact $struct)))
   ;; CHECK-NEXT:  (struct.new_default_desc $struct
   ;; CHECK-NEXT:   (local.get $desc)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT: )
-  ;; NTRAP:      (func $nonnull-cast-desc-eq (type $19) (param $desc (ref null (exact $desc))) (result (ref (exact $struct)))
+  ;; NTRAP:      (func $nonnull-cast-desc-eq (type $20) (param $desc (ref null (exact $desc))) (result (ref (exact $struct)))
   ;; NTRAP-NEXT:  (struct.new_default_desc $struct
   ;; NTRAP-NEXT:   (local.get $desc)
   ;; NTRAP-NEXT:  )
@@ -100,7 +100,7 @@
 
   ;; Test that when we optimize a struct.new to a struct.new_default, we drop
   ;; the field operands but keep the descriptor.
-  ;; CHECK:      (func $new-default-keep-desc (type $11) (result anyref)
+  ;; CHECK:      (func $new-default-keep-desc (type $12) (result anyref)
   ;; CHECK-NEXT:  (struct.new_default_desc $struct-i32
   ;; CHECK-NEXT:   (block (result (ref (exact $struct-i32.desc)))
   ;; CHECK-NEXT:    (call $effect)
@@ -108,7 +108,7 @@
   ;; CHECK-NEXT:   )
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT: )
-  ;; NTRAP:      (func $new-default-keep-desc (type $11) (result anyref)
+  ;; NTRAP:      (func $new-default-keep-desc (type $12) (result anyref)
   ;; NTRAP-NEXT:  (struct.new_default_desc $struct-i32
   ;; NTRAP-NEXT:   (block (result (ref (exact $struct-i32.desc)))
   ;; NTRAP-NEXT:    (call $effect)
@@ -128,12 +128,12 @@
     )
   )
 
-  ;; CHECK:      (func $cast-desc-eq-null-desc (type $4)
+  ;; CHECK:      (func $cast-desc-eq-null-desc (type $5)
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (unreachable)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT: )
-  ;; NTRAP:      (func $cast-desc-eq-null-desc (type $4)
+  ;; NTRAP:      (func $cast-desc-eq-null-desc (type $5)
   ;; NTRAP-NEXT:  (drop
   ;; NTRAP-NEXT:   (unreachable)
   ;; NTRAP-NEXT:  )
@@ -149,7 +149,7 @@
     )
   )
 
-  ;; CHECK:      (func $cast-desc-eq-no-glb (type $9) (param $nn-sub (ref $sub)) (param $desc (ref $desc))
+  ;; CHECK:      (func $cast-desc-eq-no-glb (type $10) (param $nn-sub (ref $sub)) (param $desc (ref $desc))
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (ref.cast_desc_eq (ref $struct)
   ;; CHECK-NEXT:    (local.get $nn-sub)
@@ -157,7 +157,7 @@
   ;; CHECK-NEXT:   )
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT: )
-  ;; NTRAP:      (func $cast-desc-eq-no-glb (type $9) (param $nn-sub (ref $sub)) (param $desc (ref $desc))
+  ;; NTRAP:      (func $cast-desc-eq-no-glb (type $10) (param $nn-sub (ref $sub)) (param $desc (ref $desc))
   ;; NTRAP-NEXT:  (drop
   ;; NTRAP-NEXT:   (block (result (ref $sub))
   ;; NTRAP-NEXT:    (local.get $nn-sub)
@@ -175,7 +175,7 @@
     )
   )
 
-  ;; CHECK:      (func $cast-desc-eq-improve-nullability (type $20) (param $nn-any (ref any)) (param $desc (ref $desc))
+  ;; CHECK:      (func $cast-desc-eq-improve-nullability (type $21) (param $nn-any (ref any)) (param $desc (ref $desc))
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (ref.cast_desc_eq (ref $struct)
   ;; CHECK-NEXT:    (local.get $nn-any)
@@ -183,7 +183,7 @@
   ;; CHECK-NEXT:   )
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT: )
-  ;; NTRAP:      (func $cast-desc-eq-improve-nullability (type $20) (param $nn-any (ref any)) (param $desc (ref $desc))
+  ;; NTRAP:      (func $cast-desc-eq-improve-nullability (type $21) (param $nn-any (ref any)) (param $desc (ref $desc))
   ;; NTRAP-NEXT:  (drop
   ;; NTRAP-NEXT:   (ref.cast_desc_eq (ref $struct)
   ;; NTRAP-NEXT:    (local.get $nn-any)
@@ -202,7 +202,7 @@
     )
   )
 
-  ;; CHECK:      (func $cast-desc-eq-only-improve-nullability (type $8) (param $any anyref) (param $desc (ref $desc))
+  ;; CHECK:      (func $cast-desc-eq-only-improve-nullability (type $9) (param $any anyref) (param $desc (ref $desc))
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (ref.cast_desc_eq (ref $struct)
   ;; CHECK-NEXT:    (local.get $any)
@@ -210,7 +210,7 @@
   ;; CHECK-NEXT:   )
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT: )
-  ;; NTRAP:      (func $cast-desc-eq-only-improve-nullability (type $8) (param $any anyref) (param $desc (ref $desc))
+  ;; NTRAP:      (func $cast-desc-eq-only-improve-nullability (type $9) (param $any anyref) (param $desc (ref $desc))
   ;; NTRAP-NEXT:  (drop
   ;; NTRAP-NEXT:   (ref.cast_desc_eq (ref $struct)
   ;; NTRAP-NEXT:    (local.get $any)
@@ -229,12 +229,12 @@
     )
   )
 
-  ;; CHECK:      (func $cast-desc-eq-unrelated-type (type $12) (param $struct (ref $struct)) (param $desc-i32 (ref (exact $struct-i32.desc)))
+  ;; CHECK:      (func $cast-desc-eq-unrelated-type (type $13) (param $struct (ref $struct)) (param $desc-i32 (ref (exact $struct-i32.desc)))
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (unreachable)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT: )
-  ;; NTRAP:      (func $cast-desc-eq-unrelated-type (type $12) (param $struct (ref $struct)) (param $desc-i32 (ref (exact $struct-i32.desc)))
+  ;; NTRAP:      (func $cast-desc-eq-unrelated-type (type $13) (param $struct (ref $struct)) (param $desc-i32 (ref (exact $struct-i32.desc)))
   ;; NTRAP-NEXT:  (drop
   ;; NTRAP-NEXT:   (unreachable)
   ;; NTRAP-NEXT:  )
@@ -249,7 +249,7 @@
     )
   )
 
-  ;; CHECK:      (func $cast-desc-eq-unrelated-type-effects (type $12) (param $struct (ref $struct)) (param $desc-i32 (ref (exact $struct-i32.desc)))
+  ;; CHECK:      (func $cast-desc-eq-unrelated-type-effects (type $13) (param $struct (ref $struct)) (param $desc-i32 (ref (exact $struct-i32.desc)))
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (block
   ;; CHECK-NEXT:    (drop
@@ -268,7 +268,7 @@
   ;; CHECK-NEXT:   )
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT: )
-  ;; NTRAP:      (func $cast-desc-eq-unrelated-type-effects (type $12) (param $struct (ref $struct)) (param $desc-i32 (ref (exact $struct-i32.desc)))
+  ;; NTRAP:      (func $cast-desc-eq-unrelated-type-effects (type $13) (param $struct (ref $struct)) (param $desc-i32 (ref (exact $struct-i32.desc)))
   ;; NTRAP-NEXT:  (drop
   ;; NTRAP-NEXT:   (block
   ;; NTRAP-NEXT:    (drop
@@ -303,7 +303,7 @@
     )
   )
 
-  ;; CHECK:      (func $cast-desc-eq-unrelated-type-nullable (type $13) (param $struct-i32 (ref null $struct-i32)) (param $desc (ref $desc))
+  ;; CHECK:      (func $cast-desc-eq-unrelated-type-nullable (type $14) (param $struct-i32 (ref null $struct-i32)) (param $desc (ref $desc))
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (ref.cast_desc_eq (ref null $struct)
   ;; CHECK-NEXT:    (local.get $struct-i32)
@@ -311,7 +311,7 @@
   ;; CHECK-NEXT:   )
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT: )
-  ;; NTRAP:      (func $cast-desc-eq-unrelated-type-nullable (type $13) (param $struct-i32 (ref null $struct-i32)) (param $desc (ref $desc))
+  ;; NTRAP:      (func $cast-desc-eq-unrelated-type-nullable (type $14) (param $struct-i32 (ref null $struct-i32)) (param $desc (ref $desc))
   ;; NTRAP-NEXT:  (drop
   ;; NTRAP-NEXT:   (ref.null none)
   ;; NTRAP-NEXT:  )
@@ -326,7 +326,7 @@
     )
   )
 
-    ;; CHECK:      (func $cast-desc-eq-unrelated-type-nullable-effects (type $13) (param $struct-i32 (ref null $struct-i32)) (param $desc (ref $desc))
+    ;; CHECK:      (func $cast-desc-eq-unrelated-type-nullable-effects (type $14) (param $struct-i32 (ref null $struct-i32)) (param $desc (ref $desc))
     ;; CHECK-NEXT:  (drop
     ;; CHECK-NEXT:   (ref.cast_desc_eq (ref null $struct)
     ;; CHECK-NEXT:    (block (result (ref null $struct-i32))
@@ -340,7 +340,7 @@
     ;; CHECK-NEXT:   )
     ;; CHECK-NEXT:  )
     ;; CHECK-NEXT: )
-    ;; NTRAP:      (func $cast-desc-eq-unrelated-type-nullable-effects (type $13) (param $struct-i32 (ref null $struct-i32)) (param $desc (ref $desc))
+    ;; NTRAP:      (func $cast-desc-eq-unrelated-type-nullable-effects (type $14) (param $struct-i32 (ref null $struct-i32)) (param $desc (ref $desc))
     ;; NTRAP-NEXT:  (drop
     ;; NTRAP-NEXT:   (block (result nullref)
     ;; NTRAP-NEXT:    (drop
@@ -375,7 +375,7 @@
     )
   )
 
-  ;; CHECK:      (func $cast-desc-eq-wrong-desc (type $4)
+  ;; CHECK:      (func $cast-desc-eq-wrong-desc (type $5)
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (ref.cast_desc_eq (ref (exact $struct))
   ;; CHECK-NEXT:    (struct.new_default_desc $struct
@@ -385,7 +385,7 @@
   ;; CHECK-NEXT:   )
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT: )
-  ;; NTRAP:      (func $cast-desc-eq-wrong-desc (type $4)
+  ;; NTRAP:      (func $cast-desc-eq-wrong-desc (type $5)
   ;; NTRAP-NEXT:  (drop
   ;; NTRAP-NEXT:   (block (result (ref (exact $struct)))
   ;; NTRAP-NEXT:    (struct.new_default_desc $struct
@@ -409,7 +409,7 @@
     )
   )
 
-    ;; CHECK:      (func $cast-desc-eq-wrong-desc-effects (type $4)
+    ;; CHECK:      (func $cast-desc-eq-wrong-desc-effects (type $5)
     ;; CHECK-NEXT:  (drop
     ;; CHECK-NEXT:   (ref.cast_desc_eq (ref (exact $struct))
     ;; CHECK-NEXT:    (block (result (ref (exact $struct)))
@@ -425,7 +425,7 @@
     ;; CHECK-NEXT:   )
     ;; CHECK-NEXT:  )
     ;; CHECK-NEXT: )
-    ;; NTRAP:      (func $cast-desc-eq-wrong-desc-effects (type $4)
+    ;; NTRAP:      (func $cast-desc-eq-wrong-desc-effects (type $5)
     ;; NTRAP-NEXT:  (local $0 (ref (exact $struct)))
     ;; NTRAP-NEXT:  (local $1 (ref (exact $desc)))
     ;; NTRAP-NEXT:  (drop
@@ -466,7 +466,7 @@
     )
   )
 
-  ;; CHECK:      (func $cast-desc-eq-weaker-nondesc-child (type $14) (param $ref anyref) (param $desc (ref $sub.desc))
+  ;; CHECK:      (func $cast-desc-eq-weaker-nondesc-child (type $15) (param $ref anyref) (param $desc (ref $sub.desc))
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (ref.cast_desc_eq (ref $sub)
   ;; CHECK-NEXT:    (local.get $ref)
@@ -474,7 +474,7 @@
   ;; CHECK-NEXT:   )
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT: )
-  ;; NTRAP:      (func $cast-desc-eq-weaker-nondesc-child (type $14) (param $ref anyref) (param $desc (ref $sub.desc))
+  ;; NTRAP:      (func $cast-desc-eq-weaker-nondesc-child (type $15) (param $ref anyref) (param $desc (ref $sub.desc))
   ;; NTRAP-NEXT:  (drop
   ;; NTRAP-NEXT:   (ref.cast_desc_eq (ref $sub)
   ;; NTRAP-NEXT:    (local.get $ref)
@@ -494,7 +494,7 @@
     )
   )
 
-  ;; CHECK:      (func $cast-desc-eq-weaker-nondesc-child-effects (type $14) (param $ref anyref) (param $desc (ref $sub.desc))
+  ;; CHECK:      (func $cast-desc-eq-weaker-nondesc-child-effects (type $15) (param $ref anyref) (param $desc (ref $sub.desc))
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (ref.cast_desc_eq (ref $sub)
   ;; CHECK-NEXT:    (ref.as_non_null
@@ -510,7 +510,7 @@
   ;; CHECK-NEXT:   )
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT: )
-  ;; NTRAP:      (func $cast-desc-eq-weaker-nondesc-child-effects (type $14) (param $ref anyref) (param $desc (ref $sub.desc))
+  ;; NTRAP:      (func $cast-desc-eq-weaker-nondesc-child-effects (type $15) (param $ref anyref) (param $desc (ref $sub.desc))
   ;; NTRAP-NEXT:  (drop
   ;; NTRAP-NEXT:   (ref.cast_desc_eq (ref $sub)
   ;; NTRAP-NEXT:    (ref.as_non_null
@@ -545,7 +545,7 @@
     )
   )
 
-  ;; CHECK:      (func $cast-desc-eq-stronger-nondesc-child (type $8) (param $ref anyref) (param $desc (ref $desc))
+  ;; CHECK:      (func $cast-desc-eq-stronger-nondesc-child (type $9) (param $ref anyref) (param $desc (ref $desc))
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (ref.cast_desc_eq (ref $struct)
   ;; CHECK-NEXT:    (ref.cast (ref $sub)
@@ -555,7 +555,7 @@
   ;; CHECK-NEXT:   )
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT: )
-  ;; NTRAP:      (func $cast-desc-eq-stronger-nondesc-child (type $8) (param $ref anyref) (param $desc (ref $desc))
+  ;; NTRAP:      (func $cast-desc-eq-stronger-nondesc-child (type $9) (param $ref anyref) (param $desc (ref $desc))
   ;; NTRAP-NEXT:  (drop
   ;; NTRAP-NEXT:   (block (result (ref $sub))
   ;; NTRAP-NEXT:    (ref.cast (ref $sub)
@@ -577,7 +577,7 @@
     )
   )
 
-  ;; CHECK:      (func $cast-desc-eq-stronger-nondesc-child-effects (type $8) (param $ref anyref) (param $desc (ref $desc))
+  ;; CHECK:      (func $cast-desc-eq-stronger-nondesc-child-effects (type $9) (param $ref anyref) (param $desc (ref $desc))
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (ref.cast_desc_eq (ref $struct)
   ;; CHECK-NEXT:    (ref.cast (ref $sub)
@@ -593,7 +593,7 @@
   ;; CHECK-NEXT:   )
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT: )
-  ;; NTRAP:      (func $cast-desc-eq-stronger-nondesc-child-effects (type $8) (param $ref anyref) (param $desc (ref $desc))
+  ;; NTRAP:      (func $cast-desc-eq-stronger-nondesc-child-effects (type $9) (param $ref anyref) (param $desc (ref $desc))
   ;; NTRAP-NEXT:  (local $2 (ref $sub))
   ;; NTRAP-NEXT:  (local $3 (ref $desc))
   ;; NTRAP-NEXT:  (drop
@@ -634,7 +634,7 @@
     )
   )
 
-  ;; CHECK:      (func $cast-desc-eq-weaker-desc-child (type $15) (param $ref anyref) (param $desc (ref $desc)) (param $sub.desc (ref $sub.desc))
+  ;; CHECK:      (func $cast-desc-eq-weaker-desc-child (type $16) (param $ref anyref) (param $desc (ref $desc)) (param $sub.desc (ref $sub.desc))
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (ref.cast_desc_eq (ref $sub)
   ;; CHECK-NEXT:    (ref.cast_desc_eq (ref $struct)
@@ -645,7 +645,7 @@
   ;; CHECK-NEXT:   )
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT: )
-  ;; NTRAP:      (func $cast-desc-eq-weaker-desc-child (type $15) (param $ref anyref) (param $desc (ref $desc)) (param $sub.desc (ref $sub.desc))
+  ;; NTRAP:      (func $cast-desc-eq-weaker-desc-child (type $16) (param $ref anyref) (param $desc (ref $desc)) (param $sub.desc (ref $sub.desc))
   ;; NTRAP-NEXT:  (drop
   ;; NTRAP-NEXT:   (ref.cast_desc_eq (ref $sub)
   ;; NTRAP-NEXT:    (block (result anyref)
@@ -670,7 +670,7 @@
     )
   )
 
-  ;; CHECK:      (func $cast-desc-eq-stronger-desc-child (type $15) (param $ref anyref) (param $desc (ref $desc)) (param $sub.desc (ref $sub.desc))
+  ;; CHECK:      (func $cast-desc-eq-stronger-desc-child (type $16) (param $ref anyref) (param $desc (ref $desc)) (param $sub.desc (ref $sub.desc))
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (ref.cast_desc_eq (ref $struct)
   ;; CHECK-NEXT:    (ref.cast_desc_eq (ref $sub)
@@ -681,7 +681,7 @@
   ;; CHECK-NEXT:   )
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT: )
-  ;; NTRAP:      (func $cast-desc-eq-stronger-desc-child (type $15) (param $ref anyref) (param $desc (ref $desc)) (param $sub.desc (ref $sub.desc))
+  ;; NTRAP:      (func $cast-desc-eq-stronger-desc-child (type $16) (param $ref anyref) (param $desc (ref $desc)) (param $sub.desc (ref $sub.desc))
   ;; NTRAP-NEXT:  (drop
   ;; NTRAP-NEXT:   (block (result (ref $sub))
   ;; NTRAP-NEXT:    (ref.cast_desc_eq (ref $sub)
@@ -705,7 +705,7 @@
     )
   )
 
-  ;; CHECK:      (func $cast-desc-eq-stronger-fallthrough (type $9) (param $sub (ref $sub)) (param $desc (ref $desc))
+  ;; CHECK:      (func $cast-desc-eq-stronger-fallthrough (type $10) (param $sub (ref $sub)) (param $desc (ref $desc))
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (ref.cast_desc_eq (ref $struct)
   ;; CHECK-NEXT:    (block (result anyref)
@@ -715,7 +715,7 @@
   ;; CHECK-NEXT:   )
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT: )
-  ;; NTRAP:      (func $cast-desc-eq-stronger-fallthrough (type $9) (param $sub (ref $sub)) (param $desc (ref $desc))
+  ;; NTRAP:      (func $cast-desc-eq-stronger-fallthrough (type $10) (param $sub (ref $sub)) (param $desc (ref $desc))
   ;; NTRAP-NEXT:  (local $2 (ref $sub))
   ;; NTRAP-NEXT:  (drop
   ;; NTRAP-NEXT:   (block (result (ref $sub))
@@ -743,7 +743,7 @@
     )
   )
 
-  ;; CHECK:      (func $cast-desc-eq-stronger-fallthrough-effects (type $9) (param $sub (ref $sub)) (param $desc (ref $desc))
+  ;; CHECK:      (func $cast-desc-eq-stronger-fallthrough-effects (type $10) (param $sub (ref $sub)) (param $desc (ref $desc))
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (ref.cast_desc_eq (ref $struct)
   ;; CHECK-NEXT:    (block (result anyref)
@@ -757,7 +757,7 @@
   ;; CHECK-NEXT:   )
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT: )
-  ;; NTRAP:      (func $cast-desc-eq-stronger-fallthrough-effects (type $9) (param $sub (ref $sub)) (param $desc (ref $desc))
+  ;; NTRAP:      (func $cast-desc-eq-stronger-fallthrough-effects (type $10) (param $sub (ref $sub)) (param $desc (ref $desc))
   ;; NTRAP-NEXT:  (local $2 (ref $sub))
   ;; NTRAP-NEXT:  (drop
   ;; NTRAP-NEXT:   (block (result (ref $sub))
@@ -795,7 +795,7 @@
     )
   )
 
-   ;; CHECK:      (func $cast-desc-eq-stronger-fallthrough-nullck (type $16) (param $sub (ref null $sub)) (param $desc (ref $desc))
+   ;; CHECK:      (func $cast-desc-eq-stronger-fallthrough-nullck (type $17) (param $sub (ref null $sub)) (param $desc (ref $desc))
    ;; CHECK-NEXT:  (drop
    ;; CHECK-NEXT:   (ref.cast_desc_eq (ref $struct)
    ;; CHECK-NEXT:    (block (result anyref)
@@ -805,7 +805,7 @@
    ;; CHECK-NEXT:   )
    ;; CHECK-NEXT:  )
    ;; CHECK-NEXT: )
-   ;; NTRAP:      (func $cast-desc-eq-stronger-fallthrough-nullck (type $16) (param $sub (ref null $sub)) (param $desc (ref $desc))
+   ;; NTRAP:      (func $cast-desc-eq-stronger-fallthrough-nullck (type $17) (param $sub (ref null $sub)) (param $desc (ref $desc))
    ;; NTRAP-NEXT:  (local $2 (ref null $sub))
    ;; NTRAP-NEXT:  (drop
    ;; NTRAP-NEXT:   (block (result (ref $sub))
@@ -834,7 +834,7 @@
     )
   )
 
-    ;; CHECK:      (func $cast-desc-eq-stronger-fallthrough-nullck-effects (type $16) (param $sub (ref null $sub)) (param $desc (ref $desc))
+    ;; CHECK:      (func $cast-desc-eq-stronger-fallthrough-nullck-effects (type $17) (param $sub (ref null $sub)) (param $desc (ref $desc))
     ;; CHECK-NEXT:  (drop
     ;; CHECK-NEXT:   (ref.cast_desc_eq (ref $struct)
     ;; CHECK-NEXT:    (block (result anyref)
@@ -848,7 +848,7 @@
     ;; CHECK-NEXT:   )
     ;; CHECK-NEXT:  )
     ;; CHECK-NEXT: )
-    ;; NTRAP:      (func $cast-desc-eq-stronger-fallthrough-nullck-effects (type $16) (param $sub (ref null $sub)) (param $desc (ref $desc))
+    ;; NTRAP:      (func $cast-desc-eq-stronger-fallthrough-nullck-effects (type $17) (param $sub (ref null $sub)) (param $desc (ref $desc))
     ;; NTRAP-NEXT:  (local $2 (ref null $sub))
     ;; NTRAP-NEXT:  (drop
     ;; NTRAP-NEXT:   (block (result (ref $sub))
@@ -888,12 +888,12 @@
     )
   )
 
-  ;; CHECK:      (func $cast-desc-eq-stronger-fallthrough-null (type $17) (param $null nullref) (param $desc (ref $desc))
+  ;; CHECK:      (func $cast-desc-eq-stronger-fallthrough-null (type $18) (param $null nullref) (param $desc (ref $desc))
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (ref.null none)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT: )
-  ;; NTRAP:      (func $cast-desc-eq-stronger-fallthrough-null (type $17) (param $null nullref) (param $desc (ref $desc))
+  ;; NTRAP:      (func $cast-desc-eq-stronger-fallthrough-null (type $18) (param $null nullref) (param $desc (ref $desc))
   ;; NTRAP-NEXT:  (drop
   ;; NTRAP-NEXT:   (ref.null none)
   ;; NTRAP-NEXT:  )
@@ -910,7 +910,7 @@
     )
   )
 
-  ;; CHECK:      (func $cast-desc-eq-stronger-fallthrough-null-effects (type $17) (param $null nullref) (param $desc (ref $desc))
+  ;; CHECK:      (func $cast-desc-eq-stronger-fallthrough-null-effects (type $18) (param $null nullref) (param $desc (ref $desc))
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (block (result nullref)
   ;; CHECK-NEXT:    (drop
@@ -929,7 +929,7 @@
   ;; CHECK-NEXT:   )
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT: )
-  ;; NTRAP:      (func $cast-desc-eq-stronger-fallthrough-null-effects (type $17) (param $null nullref) (param $desc (ref $desc))
+  ;; NTRAP:      (func $cast-desc-eq-stronger-fallthrough-null-effects (type $18) (param $null nullref) (param $desc (ref $desc))
   ;; NTRAP-NEXT:  (drop
   ;; NTRAP-NEXT:   (block (result nullref)
   ;; NTRAP-NEXT:    (drop
@@ -964,7 +964,7 @@
     )
   )
 
-  ;; CHECK:      (func $cast-desc-eq-stronger-fallthrough-null-null-desc (type $18) (param $null nullref) (param $desc (ref null $desc))
+  ;; CHECK:      (func $cast-desc-eq-stronger-fallthrough-null-null-desc (type $19) (param $null nullref) (param $desc (ref null $desc))
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (block (result nullref)
   ;; CHECK-NEXT:    (drop
@@ -976,7 +976,7 @@
   ;; CHECK-NEXT:   )
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT: )
-  ;; NTRAP:      (func $cast-desc-eq-stronger-fallthrough-null-null-desc (type $18) (param $null nullref) (param $desc (ref null $desc))
+  ;; NTRAP:      (func $cast-desc-eq-stronger-fallthrough-null-null-desc (type $19) (param $null nullref) (param $desc (ref null $desc))
   ;; NTRAP-NEXT:  (drop
   ;; NTRAP-NEXT:   (ref.null none)
   ;; NTRAP-NEXT:  )
@@ -994,7 +994,7 @@
     )
   )
 
-  ;; CHECK:      (func $cast-desc-eq-stronger-fallthrough-null-null-desc-effects (type $18) (param $null nullref) (param $desc (ref null $desc))
+  ;; CHECK:      (func $cast-desc-eq-stronger-fallthrough-null-null-desc-effects (type $19) (param $null nullref) (param $desc (ref null $desc))
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (block (result nullref)
   ;; CHECK-NEXT:    (drop
@@ -1015,7 +1015,7 @@
   ;; CHECK-NEXT:   )
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT: )
-  ;; NTRAP:      (func $cast-desc-eq-stronger-fallthrough-null-null-desc-effects (type $18) (param $null nullref) (param $desc (ref null $desc))
+  ;; NTRAP:      (func $cast-desc-eq-stronger-fallthrough-null-null-desc-effects (type $19) (param $null nullref) (param $desc (ref null $desc))
   ;; NTRAP-NEXT:  (drop
   ;; NTRAP-NEXT:   (block (result nullref)
   ;; NTRAP-NEXT:    (drop
@@ -1050,7 +1050,7 @@
     )
   )
 
-  ;; CHECK:      (func $cast-desc-eq-ref-as-non-null (type $8) (param $any anyref) (param $desc (ref $desc))
+  ;; CHECK:      (func $cast-desc-eq-ref-as-non-null (type $9) (param $any anyref) (param $desc (ref $desc))
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (ref.cast_desc_eq (ref $struct)
   ;; CHECK-NEXT:    (local.get $any)
@@ -1058,7 +1058,7 @@
   ;; CHECK-NEXT:   )
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT: )
-  ;; NTRAP:      (func $cast-desc-eq-ref-as-non-null (type $8) (param $any anyref) (param $desc (ref $desc))
+  ;; NTRAP:      (func $cast-desc-eq-ref-as-non-null (type $9) (param $any anyref) (param $desc (ref $desc))
   ;; NTRAP-NEXT:  (drop
   ;; NTRAP-NEXT:   (ref.cast_desc_eq (ref $struct)
   ;; NTRAP-NEXT:    (local.get $any)
@@ -1078,7 +1078,7 @@
     )
   )
 
-  ;; CHECK:      (func $cast-desc-eq-unreachable-desc (type $4)
+  ;; CHECK:      (func $cast-desc-eq-unreachable-desc (type $5)
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (block ;; (replaces unreachable RefCast we can't emit)
   ;; CHECK-NEXT:    (drop
@@ -1091,7 +1091,7 @@
   ;; CHECK-NEXT:   )
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT: )
-  ;; NTRAP:      (func $cast-desc-eq-unreachable-desc (type $4)
+  ;; NTRAP:      (func $cast-desc-eq-unreachable-desc (type $5)
   ;; NTRAP-NEXT:  (drop
   ;; NTRAP-NEXT:   (block ;; (replaces unreachable RefCast we can't emit)
   ;; NTRAP-NEXT:    (drop
@@ -1114,12 +1114,12 @@
     )
   )
 
-  ;; CHECK:      (func $ref.get_desc-skip-non-null (type $21) (param $ref (ref null $struct)) (result anyref)
+  ;; CHECK:      (func $ref.get_desc-skip-non-null (type $22) (param $ref (ref null $struct)) (result anyref)
   ;; CHECK-NEXT:  (ref.get_desc $struct
   ;; CHECK-NEXT:   (local.get $ref)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT: )
-  ;; NTRAP:      (func $ref.get_desc-skip-non-null (type $21) (param $ref (ref null $struct)) (result anyref)
+  ;; NTRAP:      (func $ref.get_desc-skip-non-null (type $22) (param $ref (ref null $struct)) (result anyref)
   ;; NTRAP-NEXT:  (ref.get_desc $struct
   ;; NTRAP-NEXT:   (local.get $ref)
   ;; NTRAP-NEXT:  )
@@ -1133,10 +1133,10 @@
     )
   )
 
-  ;; CHECK:      (func $ref.get_desc-trap-on-null (type $11) (result anyref)
+  ;; CHECK:      (func $ref.get_desc-trap-on-null (type $12) (result anyref)
   ;; CHECK-NEXT:  (unreachable)
   ;; CHECK-NEXT: )
-  ;; NTRAP:      (func $ref.get_desc-trap-on-null (type $11) (result anyref)
+  ;; NTRAP:      (func $ref.get_desc-trap-on-null (type $12) (result anyref)
   ;; NTRAP-NEXT:  (unreachable)
   ;; NTRAP-NEXT: )
   (func $ref.get_desc-trap-on-null (result anyref)
@@ -1148,7 +1148,7 @@
     )
   )
 
-  ;; CHECK:      (func $cast-desc-eq-skip-non-null (type $7) (param $ref (ref null $struct)) (param $desc (ref null (exact $desc)))
+  ;; CHECK:      (func $cast-desc-eq-skip-non-null (type $8) (param $ref (ref null $struct)) (param $desc (ref null (exact $desc)))
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (ref.cast_desc_eq (ref (exact $struct))
   ;; CHECK-NEXT:    (local.get $ref)
@@ -1156,7 +1156,7 @@
   ;; CHECK-NEXT:   )
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT: )
-  ;; NTRAP:      (func $cast-desc-eq-skip-non-null (type $7) (param $ref (ref null $struct)) (param $desc (ref null (exact $desc)))
+  ;; NTRAP:      (func $cast-desc-eq-skip-non-null (type $8) (param $ref (ref null $struct)) (param $desc (ref null (exact $desc)))
   ;; NTRAP-NEXT:  (drop
   ;; NTRAP-NEXT:   (ref.cast_desc_eq (ref (exact $struct))
   ;; NTRAP-NEXT:    (local.get $ref)
@@ -1176,7 +1176,7 @@
     )
   )
 
-  ;; CHECK:      (func $br_on_cast_desc_eq-skip-non-null (type $7) (param $ref (ref null $struct)) (param $desc (ref null (exact $desc)))
+  ;; CHECK:      (func $br_on_cast_desc_eq-skip-non-null (type $8) (param $ref (ref null $struct)) (param $desc (ref null (exact $desc)))
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (block $l (result (ref null $struct))
   ;; CHECK-NEXT:    (drop
@@ -1189,7 +1189,7 @@
   ;; CHECK-NEXT:   )
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT: )
-  ;; NTRAP:      (func $br_on_cast_desc_eq-skip-non-null (type $7) (param $ref (ref null $struct)) (param $desc (ref null (exact $desc)))
+  ;; NTRAP:      (func $br_on_cast_desc_eq-skip-non-null (type $8) (param $ref (ref null $struct)) (param $desc (ref null (exact $desc)))
   ;; NTRAP-NEXT:  (drop
   ;; NTRAP-NEXT:   (block $l (result (ref null $struct))
   ;; NTRAP-NEXT:    (drop
@@ -1217,7 +1217,7 @@
     )
   )
 
-  ;; CHECK:      (func $br_on_cast_desc_eq_fail-skip-non-null (type $7) (param $ref (ref null $struct)) (param $desc (ref null (exact $desc)))
+  ;; CHECK:      (func $br_on_cast_desc_eq_fail-skip-non-null (type $8) (param $ref (ref null $struct)) (param $desc (ref null (exact $desc)))
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (block $l (result (ref null $struct))
   ;; CHECK-NEXT:    (drop
@@ -1230,7 +1230,7 @@
   ;; CHECK-NEXT:   )
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT: )
-  ;; NTRAP:      (func $br_on_cast_desc_eq_fail-skip-non-null (type $7) (param $ref (ref null $struct)) (param $desc (ref null (exact $desc)))
+  ;; NTRAP:      (func $br_on_cast_desc_eq_fail-skip-non-null (type $8) (param $ref (ref null $struct)) (param $desc (ref null (exact $desc)))
   ;; NTRAP-NEXT:  (drop
   ;; NTRAP-NEXT:   (block $l (result (ref null $struct))
   ;; NTRAP-NEXT:    (drop
@@ -1258,7 +1258,7 @@
     )
   )
 
-  ;; CHECK:      (func $br_on_cast_desc_eq-trap-on-null (type $7) (param $ref (ref null $struct)) (param $desc (ref null (exact $desc)))
+  ;; CHECK:      (func $br_on_cast_desc_eq-trap-on-null (type $8) (param $ref (ref null $struct)) (param $desc (ref null (exact $desc)))
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (block $l (result (ref none))
   ;; CHECK-NEXT:    (drop
@@ -1283,7 +1283,7 @@
   ;; CHECK-NEXT:   )
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT: )
-  ;; NTRAP:      (func $br_on_cast_desc_eq-trap-on-null (type $7) (param $ref (ref null $struct)) (param $desc (ref null (exact $desc)))
+  ;; NTRAP:      (func $br_on_cast_desc_eq-trap-on-null (type $8) (param $ref (ref null $struct)) (param $desc (ref null (exact $desc)))
   ;; NTRAP-NEXT:  (drop
   ;; NTRAP-NEXT:   (block $l (result (ref none))
   ;; NTRAP-NEXT:    (drop
@@ -1322,7 +1322,7 @@
     )
   )
 
-  ;; CHECK:      (func $br_on_cast_desc_eq_fail-trap-on-null (type $7) (param $ref (ref null $struct)) (param $desc (ref null (exact $desc)))
+  ;; CHECK:      (func $br_on_cast_desc_eq_fail-trap-on-null (type $8) (param $ref (ref null $struct)) (param $desc (ref null (exact $desc)))
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (block $l (result (ref none))
   ;; CHECK-NEXT:    (drop
@@ -1347,7 +1347,7 @@
   ;; CHECK-NEXT:   )
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT: )
-  ;; NTRAP:      (func $br_on_cast_desc_eq_fail-trap-on-null (type $7) (param $ref (ref null $struct)) (param $desc (ref null (exact $desc)))
+  ;; NTRAP:      (func $br_on_cast_desc_eq_fail-trap-on-null (type $8) (param $ref (ref null $struct)) (param $desc (ref null (exact $desc)))
   ;; NTRAP-NEXT:  (drop
   ;; NTRAP-NEXT:   (block $l (result (ref none))
   ;; NTRAP-NEXT:    (drop
@@ -1386,7 +1386,7 @@
     )
   )
 
-  ;; CHECK:      (func $ref.cast_desc_eq-ref.as_non_null (type $4)
+  ;; CHECK:      (func $ref.cast_desc_eq-ref.as_non_null (type $5)
   ;; CHECK-NEXT:  (local $null (ref null $struct))
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (ref.cast_desc_eq (ref $struct)
@@ -1405,7 +1405,7 @@
   ;; CHECK-NEXT:   )
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT: )
-  ;; NTRAP:      (func $ref.cast_desc_eq-ref.as_non_null (type $4)
+  ;; NTRAP:      (func $ref.cast_desc_eq-ref.as_non_null (type $5)
   ;; NTRAP-NEXT:  (local $null (ref null $struct))
   ;; NTRAP-NEXT:  (local $1 (ref $struct))
   ;; NTRAP-NEXT:  (local $2 (ref null $desc))
@@ -1459,4 +1459,547 @@
       )
     )
   )
+
+  ;; CHECK:      (func $ref.cast_desc_eq-ref.cast (type $23) (param $x anyref)
+  ;; CHECK-NEXT:  (drop
+  ;; CHECK-NEXT:   (ref.cast_desc_eq (ref $struct)
+  ;; CHECK-NEXT:    (ref.cast (ref $struct)
+  ;; CHECK-NEXT:     (local.get $x)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:    (block (result (ref null $desc))
+  ;; CHECK-NEXT:     (return)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT:  (drop
+  ;; CHECK-NEXT:   (ref.cast_desc_eq (ref (exact $struct))
+  ;; CHECK-NEXT:    (local.get $x)
+  ;; CHECK-NEXT:    (struct.new_default $desc)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  ;; NTRAP:      (func $ref.cast_desc_eq-ref.cast (type $23) (param $x anyref)
+  ;; NTRAP-NEXT:  (local $1 (ref $struct))
+  ;; NTRAP-NEXT:  (local $2 (ref null $desc))
+  ;; NTRAP-NEXT:  (drop
+  ;; NTRAP-NEXT:   (block (result (ref $struct))
+  ;; NTRAP-NEXT:    (local.set $1
+  ;; NTRAP-NEXT:     (ref.cast (ref $struct)
+  ;; NTRAP-NEXT:      (local.get $x)
+  ;; NTRAP-NEXT:     )
+  ;; NTRAP-NEXT:    )
+  ;; NTRAP-NEXT:    (local.set $2
+  ;; NTRAP-NEXT:     (block (result (ref null $desc))
+  ;; NTRAP-NEXT:      (return)
+  ;; NTRAP-NEXT:     )
+  ;; NTRAP-NEXT:    )
+  ;; NTRAP-NEXT:    (local.get $1)
+  ;; NTRAP-NEXT:   )
+  ;; NTRAP-NEXT:  )
+  ;; NTRAP-NEXT:  (drop
+  ;; NTRAP-NEXT:   (ref.cast_desc_eq (ref (exact $struct))
+  ;; NTRAP-NEXT:    (local.get $x)
+  ;; NTRAP-NEXT:    (struct.new_default $desc)
+  ;; NTRAP-NEXT:   )
+  ;; NTRAP-NEXT:  )
+  ;; NTRAP-NEXT: )
+  (func $ref.cast_desc_eq-ref.cast (param $x anyref)
+    ;; As above with ref.as_non_null, removing the inner ref.cast would allow
+    ;; reaching the return before the cast check, so we do not optimize. (In
+    ;; NTRAP mode we end up removing the outer cast, separately.)
+    (drop
+      (ref.cast_desc_eq (ref $struct)
+        (ref.cast (ref $struct)
+          (local.get $x)
+        )
+        (block (result (ref null $desc))
+          (return)
+        )
+      )
+    )
+    ;; Without dangerous effects we can remove the inner cast.
+    (drop
+      (ref.cast_desc_eq (ref $struct)
+        (ref.cast (ref $struct)
+          (local.get $x)
+        )
+        (struct.new $desc)  ;; this has no effects
+      )
+    )
+  )
+
+  ;; CHECK:      (func $ref.cast_desc_eq-side-effects-in-desc (type $2) (param $x (ref null $struct)) (param $d (ref null $desc)) (result i32)
+  ;; CHECK-NEXT:  (ref.eq
+  ;; CHECK-NEXT:   (ref.cast_desc_eq (ref null $struct)
+  ;; CHECK-NEXT:    (local.get $x)
+  ;; CHECK-NEXT:    (block (result (ref null $desc))
+  ;; CHECK-NEXT:     (local.set $x
+  ;; CHECK-NEXT:      (ref.null none)
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:     (local.get $d)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (local.get $x)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  ;; NTRAP:      (func $ref.cast_desc_eq-side-effects-in-desc (type $4) (param $x (ref null $struct)) (param $d (ref null $desc)) (result i32)
+  ;; NTRAP-NEXT:  (local $2 (ref null $struct))
+  ;; NTRAP-NEXT:  (local $3 (ref null $desc))
+  ;; NTRAP-NEXT:  (ref.eq
+  ;; NTRAP-NEXT:   (block (result (ref null $struct))
+  ;; NTRAP-NEXT:    (local.set $2
+  ;; NTRAP-NEXT:     (local.get $x)
+  ;; NTRAP-NEXT:    )
+  ;; NTRAP-NEXT:    (local.set $3
+  ;; NTRAP-NEXT:     (block (result (ref null $desc))
+  ;; NTRAP-NEXT:      (local.set $x
+  ;; NTRAP-NEXT:       (ref.null none)
+  ;; NTRAP-NEXT:      )
+  ;; NTRAP-NEXT:      (local.get $d)
+  ;; NTRAP-NEXT:     )
+  ;; NTRAP-NEXT:    )
+  ;; NTRAP-NEXT:    (local.get $2)
+  ;; NTRAP-NEXT:   )
+  ;; NTRAP-NEXT:   (local.get $x)
+  ;; NTRAP-NEXT:  )
+  ;; NTRAP-NEXT: )
+  (func $ref.cast_desc_eq-side-effects-in-desc (param $x (ref null $struct)) (param $d (ref null $desc)) (result i32)
+    ;; The descriptor operand executes after the fallthrough value
+    ;; (local.get $x) and modifies $x, so areConsecutiveInputsEqual must not
+    ;; fold ref.eq to 1.
+    (ref.eq
+      (ref.cast_desc_eq (ref null $struct)
+        (local.get $x)
+        (block (result (ref null $desc))
+          (local.set $x (ref.null $struct))
+          (local.get $d)
+        )
+      )
+      (local.get $x)
+    )
+  )
+
+  ;; CHECK:      (func $ref.cast_desc_eq-no-side-effects-in-desc (type $2) (param $x (ref null $struct)) (param $d (ref null $desc)) (result i32)
+  ;; CHECK-NEXT:  (drop
+  ;; CHECK-NEXT:   (ref.cast_desc_eq (ref null $struct)
+  ;; CHECK-NEXT:    (local.get $x)
+  ;; CHECK-NEXT:    (local.get $d)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT:  (i32.const 1)
+  ;; CHECK-NEXT: )
+  ;; NTRAP:      (func $ref.cast_desc_eq-no-side-effects-in-desc (type $4) (param $x (ref null $struct)) (param $d (ref null $desc)) (result i32)
+  ;; NTRAP-NEXT:  (drop
+  ;; NTRAP-NEXT:   (block (result (ref null $struct))
+  ;; NTRAP-NEXT:    (local.get $x)
+  ;; NTRAP-NEXT:   )
+  ;; NTRAP-NEXT:  )
+  ;; NTRAP-NEXT:  (i32.const 1)
+  ;; NTRAP-NEXT: )
+  (func $ref.cast_desc_eq-no-side-effects-in-desc (param $x (ref null $struct)) (param $d (ref null $desc)) (result i32)
+    ;; Without interfering side effects in the descriptor operand, ref.eq can be
+    ;; folded to 1.
+    (ref.eq
+      (ref.cast_desc_eq (ref null $struct)
+        (local.get $x)
+        (local.get $d)
+      )
+      (local.get $x)
+    )
+  )
+
+  ;; CHECK:      (func $ref.cast_desc_eq-trap-in-desc (type $2) (param $x (ref null $struct)) (param $d (ref null $desc)) (result i32)
+  ;; CHECK-NEXT:  (drop
+  ;; CHECK-NEXT:   (ref.cast_desc_eq (ref null $struct)
+  ;; CHECK-NEXT:    (local.get $x)
+  ;; CHECK-NEXT:    (block (result (ref null $desc))
+  ;; CHECK-NEXT:     (unreachable)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT:  (i32.const 1)
+  ;; CHECK-NEXT: )
+  ;; NTRAP:      (func $ref.cast_desc_eq-trap-in-desc (type $4) (param $x (ref null $struct)) (param $d (ref null $desc)) (result i32)
+  ;; NTRAP-NEXT:  (drop
+  ;; NTRAP-NEXT:   (block (result (ref null $struct))
+  ;; NTRAP-NEXT:    (local.get $x)
+  ;; NTRAP-NEXT:   )
+  ;; NTRAP-NEXT:  )
+  ;; NTRAP-NEXT:  (i32.const 1)
+  ;; NTRAP-NEXT: )
+  (func $ref.cast_desc_eq-trap-in-desc (param $x (ref null $struct)) (param $d (ref null $desc)) (result i32)
+    ;; We can fold the ref.eq to 1 even when there are side effects in the
+    ;; descriptor, as long as they don't interfere.
+    (ref.eq
+      (ref.cast_desc_eq (ref null $struct)
+        (local.get $x)
+        (block (result (ref null $desc))
+          (unreachable)
+        )
+      )
+      (local.get $x)
+    )
+  )
+
+  ;; CHECK:      (func $br_on_cast_desc_eq-side-effects-in-desc (type $2) (param $x (ref null $struct)) (param $d (ref null $desc)) (result i32)
+  ;; CHECK-NEXT:  (drop
+  ;; CHECK-NEXT:   (block $l (result (ref null $struct))
+  ;; CHECK-NEXT:    (return
+  ;; CHECK-NEXT:     (ref.eq
+  ;; CHECK-NEXT:      (br_on_cast_desc_eq $l (ref null $struct) (ref null $struct)
+  ;; CHECK-NEXT:       (local.get $x)
+  ;; CHECK-NEXT:       (block (result (ref null $desc))
+  ;; CHECK-NEXT:        (local.set $x
+  ;; CHECK-NEXT:         (ref.null none)
+  ;; CHECK-NEXT:        )
+  ;; CHECK-NEXT:        (local.get $d)
+  ;; CHECK-NEXT:       )
+  ;; CHECK-NEXT:      )
+  ;; CHECK-NEXT:      (local.get $x)
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT:  (i32.const -1)
+  ;; CHECK-NEXT: )
+  ;; NTRAP:      (func $br_on_cast_desc_eq-side-effects-in-desc (type $4) (param $x (ref null $struct)) (param $d (ref null $desc)) (result i32)
+  ;; NTRAP-NEXT:  (drop
+  ;; NTRAP-NEXT:   (block $l (result (ref null $struct))
+  ;; NTRAP-NEXT:    (return
+  ;; NTRAP-NEXT:     (ref.eq
+  ;; NTRAP-NEXT:      (br_on_cast_desc_eq $l (ref null $struct) (ref null $struct)
+  ;; NTRAP-NEXT:       (local.get $x)
+  ;; NTRAP-NEXT:       (block (result (ref null $desc))
+  ;; NTRAP-NEXT:        (local.set $x
+  ;; NTRAP-NEXT:         (ref.null none)
+  ;; NTRAP-NEXT:        )
+  ;; NTRAP-NEXT:        (local.get $d)
+  ;; NTRAP-NEXT:       )
+  ;; NTRAP-NEXT:      )
+  ;; NTRAP-NEXT:      (local.get $x)
+  ;; NTRAP-NEXT:     )
+  ;; NTRAP-NEXT:    )
+  ;; NTRAP-NEXT:   )
+  ;; NTRAP-NEXT:  )
+  ;; NTRAP-NEXT:  (i32.const -1)
+  ;; NTRAP-NEXT: )
+  (func $br_on_cast_desc_eq-side-effects-in-desc (param $x (ref null $struct)) (param $d (ref null $desc)) (result i32)
+    ;; The descriptor operand executes after the fallthrough value
+    ;; (local.get $x) and modifies $x, so areConsecutiveInputsEqual must not
+    ;; fold ref.eq to 1.
+    (drop
+      (block $l (result (ref null $struct))
+        (return
+          (ref.eq
+            (br_on_cast_desc_eq $l (ref null $struct) (ref null $struct)
+              (local.get $x)
+              (block (result (ref null $desc))
+                (local.set $x (ref.null $struct))
+                (local.get $d)
+              )
+            )
+            (local.get $x)
+          )
+        )
+      )
+    )
+    (i32.const -1)
+  )
+
+  ;; CHECK:      (func $br_on_cast_desc_eq-no-side-effects-in-desc (type $2) (param $x (ref null $struct)) (param $d (ref null $desc)) (result i32)
+  ;; CHECK-NEXT:  (drop
+  ;; CHECK-NEXT:   (block $l (result (ref null $struct))
+  ;; CHECK-NEXT:    (return
+  ;; CHECK-NEXT:     (block (result i32)
+  ;; CHECK-NEXT:      (drop
+  ;; CHECK-NEXT:       (br_on_cast_desc_eq $l (ref null $struct) (ref null $struct)
+  ;; CHECK-NEXT:        (local.get $x)
+  ;; CHECK-NEXT:        (local.get $d)
+  ;; CHECK-NEXT:       )
+  ;; CHECK-NEXT:      )
+  ;; CHECK-NEXT:      (i32.const 1)
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT:  (i32.const -1)
+  ;; CHECK-NEXT: )
+  ;; NTRAP:      (func $br_on_cast_desc_eq-no-side-effects-in-desc (type $4) (param $x (ref null $struct)) (param $d (ref null $desc)) (result i32)
+  ;; NTRAP-NEXT:  (drop
+  ;; NTRAP-NEXT:   (block $l (result (ref null $struct))
+  ;; NTRAP-NEXT:    (return
+  ;; NTRAP-NEXT:     (block (result i32)
+  ;; NTRAP-NEXT:      (drop
+  ;; NTRAP-NEXT:       (br_on_cast_desc_eq $l (ref null $struct) (ref null $struct)
+  ;; NTRAP-NEXT:        (local.get $x)
+  ;; NTRAP-NEXT:        (local.get $d)
+  ;; NTRAP-NEXT:       )
+  ;; NTRAP-NEXT:      )
+  ;; NTRAP-NEXT:      (i32.const 1)
+  ;; NTRAP-NEXT:     )
+  ;; NTRAP-NEXT:    )
+  ;; NTRAP-NEXT:   )
+  ;; NTRAP-NEXT:  )
+  ;; NTRAP-NEXT:  (i32.const -1)
+  ;; NTRAP-NEXT: )
+  (func $br_on_cast_desc_eq-no-side-effects-in-desc (param $x (ref null $struct)) (param $d (ref null $desc)) (result i32)
+    ;; Without interfering side effects in the descriptor operand, ref.eq can be
+    ;; folded to 1.
+    (drop
+      (block $l (result (ref null $struct))
+        (return
+          (ref.eq
+            (br_on_cast_desc_eq $l (ref null $struct) (ref null $struct)
+              (local.get $x)
+              (local.get $d)
+            )
+            (local.get $x)
+          )
+        )
+      )
+    )
+    (i32.const -1)
+  )
+
+  ;; CHECK:      (func $br_on_cast_desc_eq-trap-in-desc (type $2) (param $x (ref null $struct)) (param $d (ref null $desc)) (result i32)
+  ;; CHECK-NEXT:  (drop
+  ;; CHECK-NEXT:   (block $l (result (ref null $struct))
+  ;; CHECK-NEXT:    (return
+  ;; CHECK-NEXT:     (block (result i32)
+  ;; CHECK-NEXT:      (drop
+  ;; CHECK-NEXT:       (br_on_cast_desc_eq $l (ref null $struct) (ref null $struct)
+  ;; CHECK-NEXT:        (local.get $x)
+  ;; CHECK-NEXT:        (block (result (ref null $desc))
+  ;; CHECK-NEXT:         (unreachable)
+  ;; CHECK-NEXT:        )
+  ;; CHECK-NEXT:       )
+  ;; CHECK-NEXT:      )
+  ;; CHECK-NEXT:      (i32.const 1)
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT:  (i32.const -1)
+  ;; CHECK-NEXT: )
+  ;; NTRAP:      (func $br_on_cast_desc_eq-trap-in-desc (type $4) (param $x (ref null $struct)) (param $d (ref null $desc)) (result i32)
+  ;; NTRAP-NEXT:  (drop
+  ;; NTRAP-NEXT:   (block $l (result (ref null $struct))
+  ;; NTRAP-NEXT:    (return
+  ;; NTRAP-NEXT:     (block (result i32)
+  ;; NTRAP-NEXT:      (drop
+  ;; NTRAP-NEXT:       (br_on_cast_desc_eq $l (ref null $struct) (ref null $struct)
+  ;; NTRAP-NEXT:        (local.get $x)
+  ;; NTRAP-NEXT:        (block (result (ref null $desc))
+  ;; NTRAP-NEXT:         (unreachable)
+  ;; NTRAP-NEXT:        )
+  ;; NTRAP-NEXT:       )
+  ;; NTRAP-NEXT:      )
+  ;; NTRAP-NEXT:      (i32.const 1)
+  ;; NTRAP-NEXT:     )
+  ;; NTRAP-NEXT:    )
+  ;; NTRAP-NEXT:   )
+  ;; NTRAP-NEXT:  )
+  ;; NTRAP-NEXT:  (i32.const -1)
+  ;; NTRAP-NEXT: )
+  (func $br_on_cast_desc_eq-trap-in-desc (param $x (ref null $struct)) (param $d (ref null $desc)) (result i32)
+    ;; We can fold the ref.eq to 1 even when there are side effects in the
+    ;; descriptor, as long as they don't interfere.
+    (drop
+      (block $l (result (ref null $struct))
+        (return
+          (ref.eq
+            (br_on_cast_desc_eq $l (ref null $struct) (ref null $struct)
+              (local.get $x)
+              (block (result (ref null $desc))
+                (unreachable)
+              )
+            )
+            (local.get $x)
+          )
+        )
+      )
+    )
+    (i32.const -1)
+  )
+
+  ;; CHECK:      (func $br_on_cast_desc_eq_fail-side-effects-in-desc (type $2) (param $x (ref null $struct)) (param $d (ref null $desc)) (result i32)
+  ;; CHECK-NEXT:  (drop
+  ;; CHECK-NEXT:   (block $l (result (ref null $struct))
+  ;; CHECK-NEXT:    (return
+  ;; CHECK-NEXT:     (ref.eq
+  ;; CHECK-NEXT:      (br_on_cast_desc_eq_fail $l (ref null $struct) (ref null $struct)
+  ;; CHECK-NEXT:       (local.get $x)
+  ;; CHECK-NEXT:       (block (result (ref null $desc))
+  ;; CHECK-NEXT:        (local.set $x
+  ;; CHECK-NEXT:         (ref.null none)
+  ;; CHECK-NEXT:        )
+  ;; CHECK-NEXT:        (local.get $d)
+  ;; CHECK-NEXT:       )
+  ;; CHECK-NEXT:      )
+  ;; CHECK-NEXT:      (local.get $x)
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT:  (i32.const -1)
+  ;; CHECK-NEXT: )
+  ;; NTRAP:      (func $br_on_cast_desc_eq_fail-side-effects-in-desc (type $4) (param $x (ref null $struct)) (param $d (ref null $desc)) (result i32)
+  ;; NTRAP-NEXT:  (drop
+  ;; NTRAP-NEXT:   (block $l (result (ref null $struct))
+  ;; NTRAP-NEXT:    (return
+  ;; NTRAP-NEXT:     (ref.eq
+  ;; NTRAP-NEXT:      (br_on_cast_desc_eq_fail $l (ref null $struct) (ref null $struct)
+  ;; NTRAP-NEXT:       (local.get $x)
+  ;; NTRAP-NEXT:       (block (result (ref null $desc))
+  ;; NTRAP-NEXT:        (local.set $x
+  ;; NTRAP-NEXT:         (ref.null none)
+  ;; NTRAP-NEXT:        )
+  ;; NTRAP-NEXT:        (local.get $d)
+  ;; NTRAP-NEXT:       )
+  ;; NTRAP-NEXT:      )
+  ;; NTRAP-NEXT:      (local.get $x)
+  ;; NTRAP-NEXT:     )
+  ;; NTRAP-NEXT:    )
+  ;; NTRAP-NEXT:   )
+  ;; NTRAP-NEXT:  )
+  ;; NTRAP-NEXT:  (i32.const -1)
+  ;; NTRAP-NEXT: )
+  (func $br_on_cast_desc_eq_fail-side-effects-in-desc (param $x (ref null $struct)) (param $d (ref null $desc)) (result i32)
+    ;; The descriptor operand executes after the fallthrough value
+    ;; (local.get $x) and modifies $x, so areConsecutiveInputsEqual must not
+    ;; fold ref.eq to 1.
+    (drop
+      (block $l (result (ref null $struct))
+        (return
+          (ref.eq
+            (br_on_cast_desc_eq_fail $l (ref null $struct) (ref null $struct)
+              (local.get $x)
+              (block (result (ref null $desc))
+                (local.set $x (ref.null $struct))
+                (local.get $d)
+              )
+            )
+            (local.get $x)
+          )
+        )
+      )
+    )
+    (i32.const -1)
+  )
+
+  ;; CHECK:      (func $br_on_cast_desc_eq_fail-no-side-effects-in-desc (type $2) (param $x (ref null $struct)) (param $d (ref null $desc)) (result i32)
+  ;; CHECK-NEXT:  (drop
+  ;; CHECK-NEXT:   (block $l (result (ref null $struct))
+  ;; CHECK-NEXT:    (return
+  ;; CHECK-NEXT:     (block (result i32)
+  ;; CHECK-NEXT:      (drop
+  ;; CHECK-NEXT:       (br_on_cast_desc_eq_fail $l (ref null $struct) (ref null $struct)
+  ;; CHECK-NEXT:        (local.get $x)
+  ;; CHECK-NEXT:        (local.get $d)
+  ;; CHECK-NEXT:       )
+  ;; CHECK-NEXT:      )
+  ;; CHECK-NEXT:      (i32.const 1)
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT:  (i32.const -1)
+  ;; CHECK-NEXT: )
+  ;; NTRAP:      (func $br_on_cast_desc_eq_fail-no-side-effects-in-desc (type $4) (param $x (ref null $struct)) (param $d (ref null $desc)) (result i32)
+  ;; NTRAP-NEXT:  (drop
+  ;; NTRAP-NEXT:   (block $l (result (ref null $struct))
+  ;; NTRAP-NEXT:    (return
+  ;; NTRAP-NEXT:     (block (result i32)
+  ;; NTRAP-NEXT:      (drop
+  ;; NTRAP-NEXT:       (br_on_cast_desc_eq_fail $l (ref null $struct) (ref null $struct)
+  ;; NTRAP-NEXT:        (local.get $x)
+  ;; NTRAP-NEXT:        (local.get $d)
+  ;; NTRAP-NEXT:       )
+  ;; NTRAP-NEXT:      )
+  ;; NTRAP-NEXT:      (i32.const 1)
+  ;; NTRAP-NEXT:     )
+  ;; NTRAP-NEXT:    )
+  ;; NTRAP-NEXT:   )
+  ;; NTRAP-NEXT:  )
+  ;; NTRAP-NEXT:  (i32.const -1)
+  ;; NTRAP-NEXT: )
+  (func $br_on_cast_desc_eq_fail-no-side-effects-in-desc (param $x (ref null $struct)) (param $d (ref null $desc)) (result i32)
+    ;; Without interfering side effects in the descriptor operand, ref.eq can be
+    ;; folded to 1.
+    (drop
+      (block $l (result (ref null $struct))
+        (return
+          (ref.eq
+            (br_on_cast_desc_eq_fail $l (ref null $struct) (ref null $struct)
+              (local.get $x)
+              (local.get $d)
+            )
+            (local.get $x)
+          )
+        )
+      )
+    )
+    (i32.const -1)
+  )
+
+  ;; CHECK:      (func $br_on_cast_desc_eq_fail-trap-in-desc (type $2) (param $x (ref null $struct)) (param $d (ref null $desc)) (result i32)
+  ;; CHECK-NEXT:  (drop
+  ;; CHECK-NEXT:   (block $l (result (ref null $struct))
+  ;; CHECK-NEXT:    (return
+  ;; CHECK-NEXT:     (block (result i32)
+  ;; CHECK-NEXT:      (drop
+  ;; CHECK-NEXT:       (br_on_cast_desc_eq_fail $l (ref null $struct) (ref null $struct)
+  ;; CHECK-NEXT:        (local.get $x)
+  ;; CHECK-NEXT:        (block (result (ref null $desc))
+  ;; CHECK-NEXT:         (unreachable)
+  ;; CHECK-NEXT:        )
+  ;; CHECK-NEXT:       )
+  ;; CHECK-NEXT:      )
+  ;; CHECK-NEXT:      (i32.const 1)
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT:  (i32.const -1)
+  ;; CHECK-NEXT: )
+  ;; NTRAP:      (func $br_on_cast_desc_eq_fail-trap-in-desc (type $4) (param $x (ref null $struct)) (param $d (ref null $desc)) (result i32)
+  ;; NTRAP-NEXT:  (drop
+  ;; NTRAP-NEXT:   (block $l (result (ref null $struct))
+  ;; NTRAP-NEXT:    (return
+  ;; NTRAP-NEXT:     (block (result i32)
+  ;; NTRAP-NEXT:      (drop
+  ;; NTRAP-NEXT:       (br_on_cast_desc_eq_fail $l (ref null $struct) (ref null $struct)
+  ;; NTRAP-NEXT:        (local.get $x)
+  ;; NTRAP-NEXT:        (block (result (ref null $desc))
+  ;; NTRAP-NEXT:         (unreachable)
+  ;; NTRAP-NEXT:        )
+  ;; NTRAP-NEXT:       )
+  ;; NTRAP-NEXT:      )
+  ;; NTRAP-NEXT:      (i32.const 1)
+  ;; NTRAP-NEXT:     )
+  ;; NTRAP-NEXT:    )
+  ;; NTRAP-NEXT:   )
+  ;; NTRAP-NEXT:  )
+  ;; NTRAP-NEXT:  (i32.const -1)
+  ;; NTRAP-NEXT: )
+  (func $br_on_cast_desc_eq_fail-trap-in-desc (param $x (ref null $struct)) (param $d (ref null $desc)) (result i32)
+    ;; We can fold the ref.eq to 1 even when there are side effects in the
+    ;; descriptor, as long as they don't interfere.
+    (drop
+      (block $l (result (ref null $struct))
+        (return
+          (ref.eq
+            (br_on_cast_desc_eq_fail $l (ref null $struct) (ref null $struct)
+              (local.get $x)
+              (block (result (ref null $desc))
+                (unreachable)
+              )
+            )
+            (local.get $x)
+          )
+        )
+      )
+    )
+    (i32.const -1)
+  )
 )
diff --git a/test/lit/passes/optimize-instructions-eh-legacy.wast b/test/lit/passes/optimize-instructions-eh-legacy.wast
index 423d17d219b..adf2202f448 100644
--- a/test/lit/passes/optimize-instructions-eh-legacy.wast
+++ b/test/lit/passes/optimize-instructions-eh-legacy.wast
@@ -52,7 +52,7 @@
     )
     ;; The 'try' above is guaranteed not to throw, so we can be sure the $x
     ;; contains 1 at this point, which is smaller than 7 (0b111), so we know the
-    ;; masking with 0b111 is not ncessary and we can only leave (local.set $x).
+    ;; masking with 0b111 is not necessary and we can only leave (local.set $x).
     (drop (i32.and (local.get $x) (i32.const 7)))
   )
 
diff --git a/test/lit/passes/optimize-instructions-gc-atomics.wast b/test/lit/passes/optimize-instructions-gc-atomics.wast
index a0283390c9a..c9d878010bd 100644
--- a/test/lit/passes/optimize-instructions-gc-atomics.wast
+++ b/test/lit/passes/optimize-instructions-gc-atomics.wast
@@ -3,11 +3,12 @@
 ;; RUN: wasm-opt %s -all --optimize-instructions -S -o - | filecheck %s
 
 (module
-  ;; CHECK:      (type $unshared (struct (field (mut i32))))
-
   ;; CHECK:      (type $shared (shared (struct (field (mut i32)))))
   (type $shared (shared (struct (field (mut i32)))))
+  ;; CHECK:      (type $unshared (struct (field (mut i32))))
   (type $unshared (struct (field (mut i32))))
+  ;; CHECK:      (type $array (shared (array (mut i32))))
+  (type $array (shared (array (mut i32))))
 
   ;; CHECK:      (func $get-unordered-unshared (type $2) (result i32)
   ;; CHECK-NEXT:  (struct.get $unshared 0
@@ -154,4 +155,131 @@
       (i32.const 0)
     )
   )
+
+  ;; CHECK:      (func $select-struct-rmw (type $4) (param $x (ref $shared)) (result i32)
+  ;; CHECK-NEXT:  (select
+  ;; CHECK-NEXT:   (struct.atomic.rmw.add $shared 0
+  ;; CHECK-NEXT:    (local.get $x)
+  ;; CHECK-NEXT:    (i32.const 1)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (struct.atomic.rmw.add $shared 0
+  ;; CHECK-NEXT:    (local.get $x)
+  ;; CHECK-NEXT:    (i32.const 1)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (i32.const 1)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $select-struct-rmw (param $x (ref $shared)) (result i32)
+    ;; The first rmw here influences the second, and we need to return the result
+    ;; of the first, which means we need a temp local. We avoid adding one and do
+    ;; not optimize here. Other instructions are tested in the functions below.
+    (select
+      (struct.atomic.rmw.add $shared 0
+        (local.get $x)
+        (i32.const 1)
+      )
+      (struct.atomic.rmw.add $shared 0
+        (local.get $x)
+        (i32.const 1)
+      )
+      (i32.const 1)
+    )
+  )
+
+  ;; CHECK:      (func $select-struct-cmpxchg (type $4) (param $x (ref $shared)) (result i32)
+  ;; CHECK-NEXT:  (select
+  ;; CHECK-NEXT:   (struct.atomic.rmw.cmpxchg $shared 0
+  ;; CHECK-NEXT:    (local.get $x)
+  ;; CHECK-NEXT:    (i32.const 1)
+  ;; CHECK-NEXT:    (i32.const 2)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (struct.atomic.rmw.cmpxchg $shared 0
+  ;; CHECK-NEXT:    (local.get $x)
+  ;; CHECK-NEXT:    (i32.const 1)
+  ;; CHECK-NEXT:    (i32.const 2)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (i32.const 1)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $select-struct-cmpxchg (param $x (ref $shared)) (result i32)
+    (select
+      (struct.atomic.rmw.cmpxchg $shared 0
+        (local.get $x)
+        (i32.const 1)
+        (i32.const 2)
+      )
+      (struct.atomic.rmw.cmpxchg $shared 0
+        (local.get $x)
+        (i32.const 1)
+        (i32.const 2)
+      )
+      (i32.const 1)
+    )
+  )
+
+  ;; CHECK:      (func $select-array-rmw (type $6) (param $x (ref $array)) (result i32)
+  ;; CHECK-NEXT:  (select
+  ;; CHECK-NEXT:   (array.atomic.rmw.add $array
+  ;; CHECK-NEXT:    (local.get $x)
+  ;; CHECK-NEXT:    (i32.const 0)
+  ;; CHECK-NEXT:    (i32.const 1)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (array.atomic.rmw.add $array
+  ;; CHECK-NEXT:    (local.get $x)
+  ;; CHECK-NEXT:    (i32.const 0)
+  ;; CHECK-NEXT:    (i32.const 1)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (i32.const 1)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $select-array-rmw (param $x (ref $array)) (result i32)
+    (select
+      (array.atomic.rmw.add $array
+        (local.get $x)
+        (i32.const 0)
+        (i32.const 1)
+      )
+      (array.atomic.rmw.add $array
+        (local.get $x)
+        (i32.const 0)
+        (i32.const 1)
+      )
+      (i32.const 1)
+    )
+  )
+
+  ;; CHECK:      (func $select-array-cmpxchg (type $6) (param $x (ref $array)) (result i32)
+  ;; CHECK-NEXT:  (select
+  ;; CHECK-NEXT:   (array.atomic.rmw.cmpxchg $array
+  ;; CHECK-NEXT:    (local.get $x)
+  ;; CHECK-NEXT:    (i32.const 0)
+  ;; CHECK-NEXT:    (i32.const 1)
+  ;; CHECK-NEXT:    (i32.const 2)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (array.atomic.rmw.cmpxchg $array
+  ;; CHECK-NEXT:    (local.get $x)
+  ;; CHECK-NEXT:    (i32.const 0)
+  ;; CHECK-NEXT:    (i32.const 1)
+  ;; CHECK-NEXT:    (i32.const 2)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (i32.const 1)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $select-array-cmpxchg (param $x (ref $array)) (result i32)
+    (select
+      (array.atomic.rmw.cmpxchg $array
+        (local.get $x)
+        (i32.const 0)
+        (i32.const 1)
+        (i32.const 2)
+      )
+      (array.atomic.rmw.cmpxchg $array
+        (local.get $x)
+        (i32.const 0)
+        (i32.const 1)
+        (i32.const 2)
+      )
+      (i32.const 1)
+    )
+  )
 )
diff --git a/test/lit/passes/optimize-instructions-publish.wast b/test/lit/passes/optimize-instructions-publish.wast
new file mode 100644
index 00000000000..14c2170fb5e
--- /dev/null
+++ b/test/lit/passes/optimize-instructions-publish.wast
@@ -0,0 +1,512 @@
+;; NOTE: Assertions have been generated by update_lit_checks.py and should not be edited.
+;; RUN: wasm-opt %s --optimize-instructions -all -S -o - | filecheck %s
+
+(module
+  ;; CHECK:      (type $shared-struct (shared (struct (field (mut i32)))))
+
+  ;; CHECK:      (type $shared-array (shared (array (mut i32))))
+
+  ;; CHECK:      (type $shared-array-func (shared (array (mut (ref null (shared func))))))
+
+  ;; CHECK:      (type $struct (struct (field (mut i32))))
+  (type $struct (struct (field (mut i32))))
+
+  (type $shared-struct (shared (struct (field (mut i32)))))
+  (type $shared-array (shared (array (mut i32))))
+  (type $shared-array-func (shared (array (mut (ref null (shared func))))))
+
+  ;; CHECK:      (data $data "hello")
+  (data $data "hello")
+  ;; CHECK:      (elem $elem (ref null (shared func)))
+  (elem $elem (ref null (shared func)))
+
+  ;; CHECK:      (func $publish-shared-struct-new (type $2) (result (ref $shared-struct))
+  ;; CHECK-NEXT:  (struct.new $shared-struct
+  ;; CHECK-NEXT:   (i32.const 1)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $publish-shared-struct-new (result (ref $shared-struct))
+    ;; Publish of a shared struct allocation can be removed.
+    (publish
+      (struct.new $shared-struct
+        (i32.const 1)
+      )
+    )
+  )
+
+  ;; CHECK:      (func $publish-shared-struct-new-default (type $2) (result (ref $shared-struct))
+  ;; CHECK-NEXT:  (struct.new_default $shared-struct)
+  ;; CHECK-NEXT: )
+  (func $publish-shared-struct-new-default (result (ref $shared-struct))
+    ;; Publish of a shared struct.new_default can be removed.
+    (publish
+      (struct.new_default $shared-struct)
+    )
+  )
+
+  ;; CHECK:      (func $publish-shared-array-new (type $4) (result (ref $shared-array))
+  ;; CHECK-NEXT:  (array.new $shared-array
+  ;; CHECK-NEXT:   (i32.const 1)
+  ;; CHECK-NEXT:   (i32.const 10)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $publish-shared-array-new (result (ref $shared-array))
+    ;; Publish of a shared array allocation can be removed.
+    (publish
+      (array.new $shared-array
+        (i32.const 1)
+        (i32.const 10)
+      )
+    )
+  )
+
+  ;; CHECK:      (func $publish-shared-array-new-default (type $4) (result (ref $shared-array))
+  ;; CHECK-NEXT:  (array.new_default $shared-array
+  ;; CHECK-NEXT:   (i32.const 10)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $publish-shared-array-new-default (result (ref $shared-array))
+    ;; Publish of a shared array.new_default can be removed.
+    (publish
+      (array.new_default $shared-array
+        (i32.const 10)
+      )
+    )
+  )
+
+  ;; CHECK:      (func $publish-shared-array-new-data (type $4) (result (ref $shared-array))
+  ;; CHECK-NEXT:  (array.new_data $shared-array $data
+  ;; CHECK-NEXT:   (i32.const 0)
+  ;; CHECK-NEXT:   (i32.const 1)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $publish-shared-array-new-data (result (ref $shared-array))
+    ;; Publish of a shared array.new_data can be removed.
+    (publish
+      (array.new_data $shared-array $data
+        (i32.const 0)
+        (i32.const 1)
+      )
+    )
+  )
+
+  ;; CHECK:      (func $publish-shared-array-new-elem (type $9) (result (ref $shared-array-func))
+  ;; CHECK-NEXT:  (array.new_elem $shared-array-func $elem
+  ;; CHECK-NEXT:   (i32.const 0)
+  ;; CHECK-NEXT:   (i32.const 1)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $publish-shared-array-new-elem (result (ref $shared-array-func))
+    ;; Publish of a shared array.new_elem can be removed.
+    (publish
+      (array.new_elem $shared-array-func $elem
+        (i32.const 0)
+        (i32.const 1)
+      )
+    )
+  )
+
+  ;; CHECK:      (func $publish-shared-array-new-fixed (type $4) (result (ref $shared-array))
+  ;; CHECK-NEXT:  (array.new_fixed $shared-array 2
+  ;; CHECK-NEXT:   (i32.const 1)
+  ;; CHECK-NEXT:   (i32.const 2)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $publish-shared-array-new-fixed (result (ref $shared-array))
+    ;; Publish of a shared array.new_fixed can be removed.
+    (publish
+      (array.new_fixed $shared-array 2
+        (i32.const 1)
+        (i32.const 2)
+      )
+    )
+  )
+
+  ;; CHECK:      (func $publish-shared-struct-new-in-block (type $2) (result (ref $shared-struct))
+  ;; CHECK-NEXT:  (nop)
+  ;; CHECK-NEXT:  (struct.new $shared-struct
+  ;; CHECK-NEXT:   (i32.const 1)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $publish-shared-struct-new-in-block (result (ref $shared-struct))
+    ;; A block is a transparent fallthrough, so publish of the block containing
+    ;; an allocation can be removed.
+    (publish
+      (block (result (ref $shared-struct))
+        (nop)
+        (struct.new $shared-struct
+          (i32.const 1)
+        )
+      )
+    )
+  )
+
+  ;; CHECK:      (func $publish-through-ref-as-alloc (type $2) (result (ref $shared-struct))
+  ;; CHECK-NEXT:  (struct.new $shared-struct
+  ;; CHECK-NEXT:   (i32.const 1)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $publish-through-ref-as-alloc (result (ref $shared-struct))
+    ;; RefAsNonNull is a transparent fallthrough, so publish of ref.as_non_null
+    ;; of an allocation can be removed.
+    (publish
+      (ref.as_non_null
+        (struct.new $shared-struct
+          (i32.const 1)
+        )
+      )
+    )
+  )
+
+  ;; CHECK:      (func $publish-publish (type $3) (param $x (ref $shared-struct)) (result (ref $shared-struct))
+  ;; CHECK-NEXT:  (publish
+  ;; CHECK-NEXT:   (local.get $x)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $publish-publish (param $x (ref $shared-struct)) (result (ref $shared-struct))
+    ;; Publish of publish can be removed.
+    (publish
+      (publish
+        (local.get $x)
+      )
+    )
+  )
+
+  ;; CHECK:      (func $publish-publish-block (type $3) (param $x (ref $shared-struct)) (result (ref $shared-struct))
+  ;; CHECK-NEXT:  (nop)
+  ;; CHECK-NEXT:  (publish
+  ;; CHECK-NEXT:   (local.get $x)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $publish-publish-block (param $x (ref $shared-struct)) (result (ref $shared-struct))
+    ;; The outer publish can look through the block to find the inner publish
+    ;; and remove itself.
+    (publish
+      (block (result (ref $shared-struct))
+        (nop)
+        (publish
+          (local.get $x)
+        )
+      )
+    )
+  )
+
+  ;; CHECK:      (func $publish-publish-alloc (type $2) (result (ref $shared-struct))
+  ;; CHECK-NEXT:  (struct.new $shared-struct
+  ;; CHECK-NEXT:   (i32.const 1)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $publish-publish-alloc (result (ref $shared-struct))
+    ;; Both publishes are removed: the inner publish wraps an allocation, and
+    ;; the outer publish wraps a publish/allocation.
+    (publish
+      (publish
+        (struct.new $shared-struct
+          (i32.const 1)
+        )
+      )
+    )
+  )
+
+  ;; CHECK:      (func $publish-unshared-struct (type $10) (param $x (ref $struct)) (result (ref $struct))
+  ;; CHECK-NEXT:  (local.get $x)
+  ;; CHECK-NEXT: )
+  (func $publish-unshared-struct (param $x (ref $struct)) (result (ref $struct))
+    ;; Publish of an unshared struct reference is removed because publish only
+    ;; affects shared objects.
+    (publish
+      (local.get $x)
+    )
+  )
+
+  ;; CHECK:      (func $publish-shared-i31 (type $11) (param $x (ref (shared i31))) (result (ref (shared i31)))
+  ;; CHECK-NEXT:  (local.get $x)
+  ;; CHECK-NEXT: )
+  (func $publish-shared-i31 (param $x (ref (shared i31))) (result (ref (shared i31)))
+    ;; Publish of a shared i31 is removed because i31 is not an array or struct.
+    (publish
+      (local.get $x)
+    )
+  )
+
+  ;; CHECK:      (func $publish-shared-extern (type $12) (param $x (ref null (shared extern))) (result (ref null (shared extern)))
+  ;; CHECK-NEXT:  (local.get $x)
+  ;; CHECK-NEXT: )
+  (func $publish-shared-extern (param $x (ref null (shared extern))) (result (ref null (shared extern)))
+    ;; Publish of a shared extern reference is removed.
+    (publish
+      (local.get $x)
+    )
+  )
+
+  ;; CHECK:      (func $publish-shared-func (type $13) (param $x (ref null (shared func))) (result (ref null (shared func)))
+  ;; CHECK-NEXT:  (local.get $x)
+  ;; CHECK-NEXT: )
+  (func $publish-shared-func (param $x (ref null (shared func))) (result (ref null (shared func)))
+    ;; Publish of a shared func reference is removed.
+    (publish
+      (local.get $x)
+    )
+  )
+
+  ;; CHECK:      (func $publish-shared-none (type $14) (param $x (ref null (shared none))) (result (ref null (shared none)))
+  ;; CHECK-NEXT:  (local.get $x)
+  ;; CHECK-NEXT: )
+  (func $publish-shared-none (param $x (ref null (shared none))) (result (ref null (shared none)))
+    ;; Publish of a shared none reference is removed.
+    (publish
+      (local.get $x)
+    )
+  )
+
+  ;; CHECK:      (func $publish-shared-null-fallthrough (type $7) (result (ref null $shared-struct))
+  ;; CHECK-NEXT:  (nop)
+  ;; CHECK-NEXT:  (ref.null (shared none))
+  ;; CHECK-NEXT: )
+  (func $publish-shared-null-fallthrough (result (ref null $shared-struct))
+    ;; The operand of publish has type (ref null $shared-struct), but its
+    ;; fallthrough is a shared null (type (ref null (shared none))). Because
+    ;; null cannot be a struct or array, the publish can be removed.
+    (publish
+      (block (result (ref null $shared-struct))
+        (nop)
+        (ref.null (shared none))
+      )
+    )
+  )
+
+  ;; CHECK:      (func $keep-shared-any (type $15) (param $x (ref (shared any))) (result (ref (shared any)))
+  ;; CHECK-NEXT:  (publish
+  ;; CHECK-NEXT:   (local.get $x)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $keep-shared-any (param $x (ref (shared any))) (result (ref (shared any)))
+    ;; Publish of a shared any reference cannot be removed because it may refer
+    ;; to a shared struct or array.
+    (publish
+      (local.get $x)
+    )
+  )
+
+  ;; CHECK:      (func $keep-shared-null-any (type $16) (param $x (ref null (shared any))) (result (ref null (shared any)))
+  ;; CHECK-NEXT:  (publish
+  ;; CHECK-NEXT:   (local.get $x)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $keep-shared-null-any (param $x (ref null (shared any))) (result (ref null (shared any)))
+    ;; Publish of a nullable shared any reference cannot be removed because it
+    ;; may refer to a shared struct or array.
+    (publish
+      (local.get $x)
+    )
+  )
+
+  ;; CHECK:      (func $keep-shared-eq (type $17) (param $x (ref (shared eq))) (result (ref (shared eq)))
+  ;; CHECK-NEXT:  (publish
+  ;; CHECK-NEXT:   (local.get $x)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $keep-shared-eq (param $x (ref (shared eq))) (result (ref (shared eq)))
+    ;; Publish of a shared eq reference cannot be removed because it may refer
+    ;; to a shared struct or array.
+    (publish
+      (local.get $x)
+    )
+  )
+
+  ;; CHECK:      (func $keep-shared-struct (type $18) (param $x (ref (shared struct))) (result (ref (shared struct)))
+  ;; CHECK-NEXT:  (publish
+  ;; CHECK-NEXT:   (local.get $x)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $keep-shared-struct (param $x (ref (shared struct))) (result (ref (shared struct)))
+    ;; Publish of a shared abstract struct cannot be removed without knowing its
+    ;; allocation history.
+    (publish
+      (local.get $x)
+    )
+  )
+
+  ;; CHECK:      (func $keep-shared-array (type $19) (param $x (ref (shared array))) (result (ref (shared array)))
+  ;; CHECK-NEXT:  (publish
+  ;; CHECK-NEXT:   (local.get $x)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $keep-shared-array (param $x (ref (shared array))) (result (ref (shared array)))
+    ;; Publish of a shared abstract array cannot be removed without knowing its
+    ;; allocation history.
+    (publish
+      (local.get $x)
+    )
+  )
+
+  ;; CHECK:      (func $keep-shared-specific-struct (type $3) (param $x (ref $shared-struct)) (result (ref $shared-struct))
+  ;; CHECK-NEXT:  (publish
+  ;; CHECK-NEXT:   (local.get $x)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $keep-shared-specific-struct (param $x (ref $shared-struct)) (result (ref $shared-struct))
+    ;; Publish of an unknown shared struct cannot be removed.
+    (publish
+      (local.get $x)
+    )
+  )
+
+  ;; CHECK:      (func $keep-shared-null-specific-struct (type $20) (param $x (ref null $shared-struct)) (result (ref null $shared-struct))
+  ;; CHECK-NEXT:  (publish
+  ;; CHECK-NEXT:   (local.get $x)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $keep-shared-null-specific-struct (param $x (ref null $shared-struct)) (result (ref null $shared-struct))
+    ;; Publish of a nullable unknown shared struct cannot be removed.
+    (publish
+      (local.get $x)
+    )
+  )
+
+  ;; CHECK:      (func $keep-shared-specific-array (type $21) (param $x (ref $shared-array)) (result (ref $shared-array))
+  ;; CHECK-NEXT:  (publish
+  ;; CHECK-NEXT:   (local.get $x)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $keep-shared-specific-array (param $x (ref $shared-array)) (result (ref $shared-array))
+    ;; Publish of an unknown shared array cannot be removed.
+    (publish
+      (local.get $x)
+    )
+  )
+
+  ;; CHECK:      (func $ref-cast-through-publish (type $3) (param $x (ref $shared-struct)) (result (ref $shared-struct))
+  ;; CHECK-NEXT:  (publish
+  ;; CHECK-NEXT:   (local.get $x)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $ref-cast-through-publish (param $x (ref $shared-struct)) (result (ref $shared-struct))
+    ;; ref.cast looks through publish to find the fallthrough type and optimizes
+    ;; away the redundant cast.
+    (ref.cast (ref $shared-struct)
+      (publish
+        (local.get $x)
+      )
+    )
+  )
+
+  ;; CHECK:      (func $ref-as-through-publish (type $3) (param $x (ref $shared-struct)) (result (ref $shared-struct))
+  ;; CHECK-NEXT:  (publish
+  ;; CHECK-NEXT:   (local.get $x)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $ref-as-through-publish (param $x (ref $shared-struct)) (result (ref $shared-struct))
+    ;; ref.as_non_null looks through publish to see the operand is already
+    ;; non-null and optimizes away the check.
+    (ref.as_non_null
+      (publish
+        (local.get $x)
+      )
+    )
+  )
+
+  ;; CHECK:      (func $struct-get-through-publish-null (type $22) (result i32)
+  ;; CHECK-NEXT:  (unreachable)
+  ;; CHECK-NEXT: )
+  (func $struct-get-through-publish-null (result i32)
+    ;; The publish is first removed because its operand is a null reference
+    ;; (which cannot be a struct or array), after which struct.get traps on the
+    ;; null reference.
+    (struct.get $shared-struct 0
+      (publish
+        (ref.null $shared-struct)
+      )
+    )
+  )
+
+  ;; CHECK:      (func $publish-unreachable (type $8) (result (ref (shared any)))
+  ;; CHECK-NEXT:  (publish
+  ;; CHECK-NEXT:   (unreachable)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $publish-unreachable (result (ref (shared any)))
+    ;; Publish of an unreachable instruction is not modified.
+    (publish
+      (unreachable)
+    )
+  )
+
+  ;; CHECK:      (func $publish-unreachable-block (type $8) (result (ref (shared any)))
+  ;; CHECK-NEXT:  (nop)
+  ;; CHECK-NEXT:  (unreachable)
+  ;; CHECK-NEXT: )
+  (func $publish-unreachable-block (result (ref (shared any)))
+    ;; Publish of a block containing an unreachable instruction is eliminated
+    ;; because the fallthrough has a non-shared type.
+    (publish
+      (block (result (ref (shared any)))
+        (nop)
+        (unreachable)
+      )
+    )
+  )
+
+  ;; CHECK:      (func $publish-tee (type $7) (result (ref null $shared-struct))
+  ;; CHECK-NEXT:  (local $x (ref null $shared-struct))
+  ;; CHECK-NEXT:  (local.tee $x
+  ;; CHECK-NEXT:   (struct.new $shared-struct
+  ;; CHECK-NEXT:    (i32.const 1)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $publish-tee (result (ref null $shared-struct))
+    ;; An intervening local.tee does not prevent the publish from being removed.
+    ;; If the teed local was used to write to the object before publishing it,
+    ;; we would not remove the publish (see next test).
+    (local $x (ref null $shared-struct))
+    (publish
+      (local.tee $x
+        (struct.new $shared-struct
+          (i32.const 1)
+        )
+      )
+    )
+  )
+
+  ;; CHECK:      (func $publish-write-fallthrough (type $23) (result (ref null (shared any)))
+  ;; CHECK-NEXT:  (local $s (ref null $shared-struct))
+  ;; CHECK-NEXT:  (block $l (result (ref null (shared any)))
+  ;; CHECK-NEXT:   (publish
+  ;; CHECK-NEXT:    (br_if $l
+  ;; CHECK-NEXT:     (local.tee $s
+  ;; CHECK-NEXT:      (struct.new_default $shared-struct)
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:     (block (result i32)
+  ;; CHECK-NEXT:      (struct.set $shared-struct 0
+  ;; CHECK-NEXT:       (local.get $s)
+  ;; CHECK-NEXT:       (i32.const 10)
+  ;; CHECK-NEXT:      )
+  ;; CHECK-NEXT:      (i32.const 0)
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $publish-write-fallthrough (result (ref null (shared any)))
+    (local $s (ref null $shared-struct))
+    (block $l (result (ref null (shared any)))
+      ;; Now the tee is used to write to the published object. We do not
+      ;; optimize.
+      (publish
+        (br_if $l
+          (local.tee $s
+            (struct.new_default $shared-struct)
+          )
+          (block (result i32)
+            (struct.set $shared-struct 0
+              (local.get $s)
+              (i32.const 10)
+            )
+            (i32.const 0)
+          )
+        )
+      )
+    )
+  )
+)
diff --git a/test/lit/passes/optimize-instructions-resume.wast b/test/lit/passes/optimize-instructions-resume.wast
new file mode 100644
index 00000000000..e00502dd0aa
--- /dev/null
+++ b/test/lit/passes/optimize-instructions-resume.wast
@@ -0,0 +1,1137 @@
+;; NOTE: Assertions have been generated by update_lit_checks.py and should not be edited.
+;; Test that optimize-instructions turns resumptions of continuations that never
+;; suspend into direct calls.
+
+;; RUN: wasm-opt %s --all-features --generate-global-effects --optimize-instructions -S -o - | filecheck %s --check-prefix NO-TNH
+;; RUN: wasm-opt %s --all-features --generate-global-effects --traps-never-happen --optimize-instructions -S -o - | filecheck %s --check-prefix TNH
+;; RUN: wasm-opt %s --all-features --generate-global-effects --optimize-instructions --vacuum -S -o - | filecheck %s --check-prefix VACUUM
+
+(module
+  ;; NO-TNH:      (type $sig-none (func))
+
+  ;; NO-TNH:      (type $cont-none (cont $sig-none))
+
+  ;; NO-TNH:      (type $sig-binary (func (param i32 i32) (result i32)))
+
+  ;; NO-TNH:      (type $cont-binary (cont $sig-binary))
+
+  ;; NO-TNH:      (type $sig-unary (func (param i32) (result i32)))
+
+  ;; NO-TNH:      (type $sig-any (func (param (ref any)) (result (ref any))))
+
+  ;; NO-TNH:      (import "env" "imported" (func $imported (type $sig-none)))
+  ;; TNH:      (type $sig-none (func))
+
+  ;; TNH:      (type $cont-none (cont $sig-none))
+
+  ;; TNH:      (type $sig-binary (func (param i32 i32) (result i32)))
+
+  ;; TNH:      (type $cont-binary (cont $sig-binary))
+
+  ;; TNH:      (type $sig-unary (func (param i32) (result i32)))
+
+  ;; TNH:      (type $sig-any (func (param (ref any)) (result (ref any))))
+
+  ;; TNH:      (import "env" "imported" (func $imported (type $sig-none)))
+  ;; VACUUM:      (type $sig-none (func))
+
+  ;; VACUUM:      (type $cont-none (cont $sig-none))
+
+  ;; VACUUM:      (type $sig-binary (func (param i32 i32) (result i32)))
+
+  ;; VACUUM:      (type $cont-binary (cont $sig-binary))
+
+  ;; VACUUM:      (type $sig-unary (func (param i32) (result i32)))
+
+  ;; VACUUM:      (type $sig-any (func (param (ref any)) (result (ref any))))
+
+  ;; VACUUM:      (import "env" "imported" (func $imported (type $sig-none)))
+  (import "env" "imported" (func $imported (type $sig-none)))
+
+  ;; NO-TNH:      (global $counter (mut i32) (i32.const 0))
+
+  ;; NO-TNH:      (tag $tag (type $sig-none))
+  ;; TNH:      (global $counter (mut i32) (i32.const 0))
+
+  ;; TNH:      (tag $tag (type $sig-none))
+  ;; VACUUM:      (global $counter (mut i32) (i32.const 0))
+
+  ;; VACUUM:      (tag $tag (type $sig-none))
+  (tag $tag)
+  ;; NO-TNH:      (tag $tag-i32 (type $7) (param i32))
+  ;; TNH:      (tag $tag-i32 (type $7) (param i32))
+  ;; VACUUM:      (tag $tag-i32 (type $7) (param i32))
+  (tag $tag-i32 (param i32))
+
+  (type $sig-none (func))
+  (type $sig-binary (func (param i32 i32) (result i32)))
+  (type $sig-unary (func (param i32) (result i32)))
+  (type $sig-any (func (param (ref any)) (result (ref any))))
+
+  (type $cont-none (cont $sig-none))
+  (type $cont-binary (cont $sig-binary))
+  (type $cont-unary (cont $sig-unary))
+  (type $cont-any (cont $sig-any))
+
+  (global $counter (mut i32) (i32.const 0))
+
+  ;; NO-TNH:      (func $pure (type $sig-none)
+  ;; NO-TNH-NEXT:  (nop)
+  ;; NO-TNH-NEXT: )
+  ;; TNH:      (func $pure (type $sig-none)
+  ;; TNH-NEXT:  (nop)
+  ;; TNH-NEXT: )
+  ;; VACUUM:      (func $pure (type $sig-none)
+  ;; VACUUM-NEXT:  (nop)
+  ;; VACUUM-NEXT: )
+  (func $pure (type $sig-none)
+    (nop)
+  )
+
+  ;; NO-TNH:      (func $pure-binary (type $sig-binary) (param $x i32) (param $y i32) (result i32)
+  ;; NO-TNH-NEXT:  (i32.add
+  ;; NO-TNH-NEXT:   (local.get $x)
+  ;; NO-TNH-NEXT:   (local.get $y)
+  ;; NO-TNH-NEXT:  )
+  ;; NO-TNH-NEXT: )
+  ;; TNH:      (func $pure-binary (type $sig-binary) (param $x i32) (param $y i32) (result i32)
+  ;; TNH-NEXT:  (i32.add
+  ;; TNH-NEXT:   (local.get $x)
+  ;; TNH-NEXT:   (local.get $y)
+  ;; TNH-NEXT:  )
+  ;; TNH-NEXT: )
+  ;; VACUUM:      (func $pure-binary (type $sig-binary) (param $x i32) (param $y i32) (result i32)
+  ;; VACUUM-NEXT:  (i32.add
+  ;; VACUUM-NEXT:   (local.get $x)
+  ;; VACUUM-NEXT:   (local.get $y)
+  ;; VACUUM-NEXT:  )
+  ;; VACUUM-NEXT: )
+  (func $pure-binary (type $sig-binary) (param $x i32) (param $y i32) (result i32)
+    (i32.add (local.get $x) (local.get $y))
+  )
+
+  ;; NO-TNH:      (func $pure-any (type $sig-any) (param $x (ref any)) (result (ref any))
+  ;; NO-TNH-NEXT:  (local.get $x)
+  ;; NO-TNH-NEXT: )
+  ;; TNH:      (func $pure-any (type $sig-any) (param $x (ref any)) (result (ref any))
+  ;; TNH-NEXT:  (local.get $x)
+  ;; TNH-NEXT: )
+  ;; VACUUM:      (func $pure-any (type $sig-any) (param $x (ref any)) (result (ref any))
+  ;; VACUUM-NEXT:  (local.get $x)
+  ;; VACUUM-NEXT: )
+  (func $pure-any (type $sig-any) (param $x (ref any)) (result (ref any))
+    (local.get $x)
+  )
+
+  ;; NO-TNH:      (func $suspending (type $sig-none)
+  ;; NO-TNH-NEXT:  (suspend $tag)
+  ;; NO-TNH-NEXT: )
+  ;; TNH:      (func $suspending (type $sig-none)
+  ;; TNH-NEXT:  (suspend $tag)
+  ;; TNH-NEXT: )
+  ;; VACUUM:      (func $suspending (type $sig-none)
+  ;; VACUUM-NEXT:  (suspend $tag)
+  ;; VACUUM-NEXT: )
+  (func $suspending (type $sig-none)
+    (suspend $tag)
+  )
+
+  ;; NO-TNH:      (func $caller-of-suspending (type $sig-none)
+  ;; NO-TNH-NEXT:  (call $suspending)
+  ;; NO-TNH-NEXT: )
+  ;; TNH:      (func $caller-of-suspending (type $sig-none)
+  ;; TNH-NEXT:  (call $suspending)
+  ;; TNH-NEXT: )
+  ;; VACUUM:      (func $caller-of-suspending (type $sig-none)
+  ;; VACUUM-NEXT:  (call $suspending)
+  ;; VACUUM-NEXT: )
+  (func $caller-of-suspending (type $sig-none)
+    (call $suspending)
+  )
+
+  ;; NO-TNH:      (func $same-sig-pure (type $sig-unary) (param $x i32) (result i32)
+  ;; NO-TNH-NEXT:  (local.get $x)
+  ;; NO-TNH-NEXT: )
+  ;; TNH:      (func $same-sig-pure (type $sig-unary) (param $x i32) (result i32)
+  ;; TNH-NEXT:  (local.get $x)
+  ;; TNH-NEXT: )
+  ;; VACUUM:      (func $same-sig-pure (type $sig-unary) (param $x i32) (result i32)
+  ;; VACUUM-NEXT:  (local.get $x)
+  ;; VACUUM-NEXT: )
+  (func $same-sig-pure (type $sig-unary) (param $x i32) (result i32)
+    (local.get $x)
+  )
+
+  ;; NO-TNH:      (func $same-sig-suspending (type $sig-unary) (param $x i32) (result i32)
+  ;; NO-TNH-NEXT:  (suspend $tag-i32
+  ;; NO-TNH-NEXT:   (local.get $x)
+  ;; NO-TNH-NEXT:  )
+  ;; NO-TNH-NEXT:  (local.get $x)
+  ;; NO-TNH-NEXT: )
+  ;; TNH:      (func $same-sig-suspending (type $sig-unary) (param $x i32) (result i32)
+  ;; TNH-NEXT:  (suspend $tag-i32
+  ;; TNH-NEXT:   (local.get $x)
+  ;; TNH-NEXT:  )
+  ;; TNH-NEXT:  (local.get $x)
+  ;; TNH-NEXT: )
+  ;; VACUUM:      (func $same-sig-suspending (type $sig-unary) (param $x i32) (result i32)
+  ;; VACUUM-NEXT:  (suspend $tag-i32
+  ;; VACUUM-NEXT:   (local.get $x)
+  ;; VACUUM-NEXT:  )
+  ;; VACUUM-NEXT:  (local.get $x)
+  ;; VACUUM-NEXT: )
+  (func $same-sig-suspending (type $sig-unary) (param $x i32) (result i32)
+    (suspend $tag-i32 (local.get $x))
+    (local.get $x)
+  )
+
+  ;; NO-TNH:      (func $side-effect-1 (type $2) (result i32)
+  ;; NO-TNH-NEXT:  (global.set $counter
+  ;; NO-TNH-NEXT:   (i32.add
+  ;; NO-TNH-NEXT:    (global.get $counter)
+  ;; NO-TNH-NEXT:    (i32.const 1)
+  ;; NO-TNH-NEXT:   )
+  ;; NO-TNH-NEXT:  )
+  ;; NO-TNH-NEXT:  (i32.const 10)
+  ;; NO-TNH-NEXT: )
+  ;; TNH:      (func $side-effect-1 (type $2) (result i32)
+  ;; TNH-NEXT:  (global.set $counter
+  ;; TNH-NEXT:   (i32.add
+  ;; TNH-NEXT:    (global.get $counter)
+  ;; TNH-NEXT:    (i32.const 1)
+  ;; TNH-NEXT:   )
+  ;; TNH-NEXT:  )
+  ;; TNH-NEXT:  (i32.const 10)
+  ;; TNH-NEXT: )
+  ;; VACUUM:      (func $side-effect-1 (type $2) (result i32)
+  ;; VACUUM-NEXT:  (global.set $counter
+  ;; VACUUM-NEXT:   (i32.add
+  ;; VACUUM-NEXT:    (global.get $counter)
+  ;; VACUUM-NEXT:    (i32.const 1)
+  ;; VACUUM-NEXT:   )
+  ;; VACUUM-NEXT:  )
+  ;; VACUUM-NEXT:  (i32.const 10)
+  ;; VACUUM-NEXT: )
+  (func $side-effect-1 (result i32)
+    (global.set $counter (i32.add (global.get $counter) (i32.const 1)))
+    (i32.const 10)
+  )
+
+  ;; NO-TNH:      (func $side-effect-2 (type $2) (result i32)
+  ;; NO-TNH-NEXT:  (global.set $counter
+  ;; NO-TNH-NEXT:   (i32.add
+  ;; NO-TNH-NEXT:    (global.get $counter)
+  ;; NO-TNH-NEXT:    (i32.const 2)
+  ;; NO-TNH-NEXT:   )
+  ;; NO-TNH-NEXT:  )
+  ;; NO-TNH-NEXT:  (i32.const 20)
+  ;; NO-TNH-NEXT: )
+  ;; TNH:      (func $side-effect-2 (type $2) (result i32)
+  ;; TNH-NEXT:  (global.set $counter
+  ;; TNH-NEXT:   (i32.add
+  ;; TNH-NEXT:    (global.get $counter)
+  ;; TNH-NEXT:    (i32.const 2)
+  ;; TNH-NEXT:   )
+  ;; TNH-NEXT:  )
+  ;; TNH-NEXT:  (i32.const 20)
+  ;; TNH-NEXT: )
+  ;; VACUUM:      (func $side-effect-2 (type $2) (result i32)
+  ;; VACUUM-NEXT:  (global.set $counter
+  ;; VACUUM-NEXT:   (i32.add
+  ;; VACUUM-NEXT:    (global.get $counter)
+  ;; VACUUM-NEXT:    (i32.const 2)
+  ;; VACUUM-NEXT:   )
+  ;; VACUUM-NEXT:  )
+  ;; VACUUM-NEXT:  (i32.const 20)
+  ;; VACUUM-NEXT: )
+  (func $side-effect-2 (result i32)
+    (global.set $counter (i32.add (global.get $counter) (i32.const 2)))
+    (i32.const 20)
+  )
+
+  ;; NO-TNH:      (func $side-effect-3 (type $sig-none)
+  ;; NO-TNH-NEXT:  (global.set $counter
+  ;; NO-TNH-NEXT:   (i32.add
+  ;; NO-TNH-NEXT:    (global.get $counter)
+  ;; NO-TNH-NEXT:    (i32.const 3)
+  ;; NO-TNH-NEXT:   )
+  ;; NO-TNH-NEXT:  )
+  ;; NO-TNH-NEXT: )
+  ;; TNH:      (func $side-effect-3 (type $sig-none)
+  ;; TNH-NEXT:  (global.set $counter
+  ;; TNH-NEXT:   (i32.add
+  ;; TNH-NEXT:    (global.get $counter)
+  ;; TNH-NEXT:    (i32.const 3)
+  ;; TNH-NEXT:   )
+  ;; TNH-NEXT:  )
+  ;; TNH-NEXT: )
+  ;; VACUUM:      (func $side-effect-3 (type $sig-none)
+  ;; VACUUM-NEXT:  (global.set $counter
+  ;; VACUUM-NEXT:   (i32.add
+  ;; VACUUM-NEXT:    (global.get $counter)
+  ;; VACUUM-NEXT:    (i32.const 3)
+  ;; VACUUM-NEXT:   )
+  ;; VACUUM-NEXT:  )
+  ;; VACUUM-NEXT: )
+  (func $side-effect-3
+    (global.set $counter (i32.add (global.get $counter) (i32.const 3)))
+  )
+
+  ;; NO-TNH:      (func $test-resume-null (type $sig-none)
+  ;; NO-TNH-NEXT:  (unreachable)
+  ;; NO-TNH-NEXT: )
+  ;; TNH:      (func $test-resume-null (type $sig-none)
+  ;; TNH-NEXT:  (unreachable)
+  ;; TNH-NEXT: )
+  ;; VACUUM:      (func $test-resume-null (type $sig-none)
+  ;; VACUUM-NEXT:  (unreachable)
+  ;; VACUUM-NEXT: )
+  (func $test-resume-null
+    ;; Resume of null traps: replaced with unreachable.
+    (resume $cont-none
+      (ref.null $cont-none)
+    )
+  )
+
+  ;; NO-TNH:      (func $test-resume-null-operands (type $sig-none)
+  ;; NO-TNH-NEXT:  (drop
+  ;; NO-TNH-NEXT:   (block
+  ;; NO-TNH-NEXT:    (drop
+  ;; NO-TNH-NEXT:     (call $side-effect-1)
+  ;; NO-TNH-NEXT:    )
+  ;; NO-TNH-NEXT:    (drop
+  ;; NO-TNH-NEXT:     (call $side-effect-2)
+  ;; NO-TNH-NEXT:    )
+  ;; NO-TNH-NEXT:    (unreachable)
+  ;; NO-TNH-NEXT:   )
+  ;; NO-TNH-NEXT:  )
+  ;; NO-TNH-NEXT: )
+  ;; TNH:      (func $test-resume-null-operands (type $sig-none)
+  ;; TNH-NEXT:  (drop
+  ;; TNH-NEXT:   (block
+  ;; TNH-NEXT:    (drop
+  ;; TNH-NEXT:     (call $side-effect-1)
+  ;; TNH-NEXT:    )
+  ;; TNH-NEXT:    (drop
+  ;; TNH-NEXT:     (call $side-effect-2)
+  ;; TNH-NEXT:    )
+  ;; TNH-NEXT:    (unreachable)
+  ;; TNH-NEXT:   )
+  ;; TNH-NEXT:  )
+  ;; TNH-NEXT: )
+  ;; VACUUM:      (func $test-resume-null-operands (type $sig-none)
+  ;; VACUUM-NEXT:  (drop
+  ;; VACUUM-NEXT:   (block
+  ;; VACUUM-NEXT:    (drop
+  ;; VACUUM-NEXT:     (call $side-effect-1)
+  ;; VACUUM-NEXT:    )
+  ;; VACUUM-NEXT:    (drop
+  ;; VACUUM-NEXT:     (call $side-effect-2)
+  ;; VACUUM-NEXT:    )
+  ;; VACUUM-NEXT:    (unreachable)
+  ;; VACUUM-NEXT:   )
+  ;; VACUUM-NEXT:  )
+  ;; VACUUM-NEXT: )
+  (func $test-resume-null-operands
+    ;; Operands are evaluated and dropped before the null trap.
+    (resume $cont-binary
+      (call $side-effect-1)
+      (call $side-effect-2)
+      (ref.null $cont-binary)
+    )
+    (drop)
+  )
+
+  ;; NO-TNH:      (func $test-resume-skip-non-null-cast (type $9) (param $c (ref null $cont-none))
+  ;; NO-TNH-NEXT:  (resume $cont-none
+  ;; NO-TNH-NEXT:   (local.get $c)
+  ;; NO-TNH-NEXT:  )
+  ;; NO-TNH-NEXT: )
+  ;; TNH:      (func $test-resume-skip-non-null-cast (type $9) (param $c (ref null $cont-none))
+  ;; TNH-NEXT:  (resume $cont-none
+  ;; TNH-NEXT:   (local.get $c)
+  ;; TNH-NEXT:  )
+  ;; TNH-NEXT: )
+  ;; VACUUM:      (func $test-resume-skip-non-null-cast (type $9) (param $c (ref null $cont-none))
+  ;; VACUUM-NEXT:  (resume $cont-none
+  ;; VACUUM-NEXT:   (local.get $c)
+  ;; VACUUM-NEXT:  )
+  ;; VACUUM-NEXT: )
+  (func $test-resume-skip-non-null-cast (param $c (ref null $cont-none))
+    ;; Redundant ref.as_non_null on continuation is stripped because resume
+    ;; traps on null.
+    (resume $cont-none
+      (ref.as_non_null
+        (local.get $c)
+      )
+    )
+  )
+
+  ;; NO-TNH:      (func $test-resume-null-arm-tnh (type $6) (param $cond i32) (param $c (ref $cont-none))
+  ;; NO-TNH-NEXT:  (resume $cont-none
+  ;; NO-TNH-NEXT:   (if (result (ref null $cont-none))
+  ;; NO-TNH-NEXT:    (local.get $cond)
+  ;; NO-TNH-NEXT:    (then
+  ;; NO-TNH-NEXT:     (ref.null nocont)
+  ;; NO-TNH-NEXT:    )
+  ;; NO-TNH-NEXT:    (else
+  ;; NO-TNH-NEXT:     (local.get $c)
+  ;; NO-TNH-NEXT:    )
+  ;; NO-TNH-NEXT:   )
+  ;; NO-TNH-NEXT:  )
+  ;; NO-TNH-NEXT: )
+  ;; TNH:      (func $test-resume-null-arm-tnh (type $6) (param $cond i32) (param $c (ref $cont-none))
+  ;; TNH-NEXT:  (resume $cont-none
+  ;; TNH-NEXT:   (block (result (ref $cont-none))
+  ;; TNH-NEXT:    (drop
+  ;; TNH-NEXT:     (local.get $cond)
+  ;; TNH-NEXT:    )
+  ;; TNH-NEXT:    (local.get $c)
+  ;; TNH-NEXT:   )
+  ;; TNH-NEXT:  )
+  ;; TNH-NEXT: )
+  ;; VACUUM:      (func $test-resume-null-arm-tnh (type $6) (param $cond i32) (param $c (ref $cont-none))
+  ;; VACUUM-NEXT:  (resume $cont-none
+  ;; VACUUM-NEXT:   (if (result (ref null $cont-none))
+  ;; VACUUM-NEXT:    (local.get $cond)
+  ;; VACUUM-NEXT:    (then
+  ;; VACUUM-NEXT:     (ref.null nocont)
+  ;; VACUUM-NEXT:    )
+  ;; VACUUM-NEXT:    (else
+  ;; VACUUM-NEXT:     (local.get $c)
+  ;; VACUUM-NEXT:    )
+  ;; VACUUM-NEXT:   )
+  ;; VACUUM-NEXT:  )
+  ;; VACUUM-NEXT: )
+  (func $test-resume-null-arm-tnh (param $cond i32) (param $c (ref $cont-none))
+    ;; Under TNH, if-arms that flow out null are assumed never taken.
+    (resume $cont-none
+      (if (result (ref null $cont-none))
+        (local.get $cond)
+        (then
+          (ref.null $cont-none)
+        )
+        (else
+          (local.get $c)
+        )
+      )
+    )
+  )
+
+  ;; NO-TNH:      (func $test-resume-null-select-tnh (type $6) (param $cond i32) (param $c (ref $cont-none))
+  ;; NO-TNH-NEXT:  (resume $cont-none
+  ;; NO-TNH-NEXT:   (select (result (ref null $cont-none))
+  ;; NO-TNH-NEXT:    (ref.null nocont)
+  ;; NO-TNH-NEXT:    (local.get $c)
+  ;; NO-TNH-NEXT:    (local.get $cond)
+  ;; NO-TNH-NEXT:   )
+  ;; NO-TNH-NEXT:  )
+  ;; NO-TNH-NEXT: )
+  ;; TNH:      (func $test-resume-null-select-tnh (type $6) (param $cond i32) (param $c (ref $cont-none))
+  ;; TNH-NEXT:  (resume $cont-none
+  ;; TNH-NEXT:   (block (result (ref $cont-none))
+  ;; TNH-NEXT:    (drop
+  ;; TNH-NEXT:     (ref.null nocont)
+  ;; TNH-NEXT:    )
+  ;; TNH-NEXT:    (block (result (ref $cont-none))
+  ;; TNH-NEXT:     (drop
+  ;; TNH-NEXT:      (local.get $cond)
+  ;; TNH-NEXT:     )
+  ;; TNH-NEXT:     (local.get $c)
+  ;; TNH-NEXT:    )
+  ;; TNH-NEXT:   )
+  ;; TNH-NEXT:  )
+  ;; TNH-NEXT: )
+  ;; VACUUM:      (func $test-resume-null-select-tnh (type $6) (param $cond i32) (param $c (ref $cont-none))
+  ;; VACUUM-NEXT:  (resume $cont-none
+  ;; VACUUM-NEXT:   (select (result (ref null $cont-none))
+  ;; VACUUM-NEXT:    (ref.null nocont)
+  ;; VACUUM-NEXT:    (local.get $c)
+  ;; VACUUM-NEXT:    (local.get $cond)
+  ;; VACUUM-NEXT:   )
+  ;; VACUUM-NEXT:  )
+  ;; VACUUM-NEXT: )
+  (func $test-resume-null-select-tnh (param $cond i32) (param $c (ref $cont-none))
+    ;; Under TNH, select branches that flow out null are assumed never taken.
+    (resume $cont-none
+      (select (result (ref null $cont-none))
+        (ref.null $cont-none)
+        (local.get $c)
+        (local.get $cond)
+      )
+    )
+  )
+
+  ;; NO-TNH:      (func $test-basic (type $sig-none)
+  ;; NO-TNH-NEXT:  (call $pure)
+  ;; NO-TNH-NEXT: )
+  ;; TNH:      (func $test-basic (type $sig-none)
+  ;; TNH-NEXT:  (call $pure)
+  ;; TNH-NEXT: )
+  ;; VACUUM:      (func $test-basic (type $sig-none)
+  ;; VACUUM-NEXT:  (nop)
+  ;; VACUUM-NEXT: )
+  (func $test-basic
+    ;; Basic rewrite: resume of non-suspending continuation becomes direct
+    ;; call.
+    (resume $cont-none
+      (cont.new $cont-none (ref.func $pure))
+    )
+  )
+
+  ;; NO-TNH:      (func $test-binary (type $2) (result i32)
+  ;; NO-TNH-NEXT:  (call $pure-binary
+  ;; NO-TNH-NEXT:   (i32.const 1)
+  ;; NO-TNH-NEXT:   (i32.const 2)
+  ;; NO-TNH-NEXT:  )
+  ;; NO-TNH-NEXT: )
+  ;; TNH:      (func $test-binary (type $2) (result i32)
+  ;; TNH-NEXT:  (call $pure-binary
+  ;; TNH-NEXT:   (i32.const 1)
+  ;; TNH-NEXT:   (i32.const 2)
+  ;; TNH-NEXT:  )
+  ;; TNH-NEXT: )
+  ;; VACUUM:      (func $test-binary (type $2) (result i32)
+  ;; VACUUM-NEXT:  (call $pure-binary
+  ;; VACUUM-NEXT:   (i32.const 1)
+  ;; VACUUM-NEXT:   (i32.const 2)
+  ;; VACUUM-NEXT:  )
+  ;; VACUUM-NEXT: )
+  (func $test-binary (result i32)
+    ;; Operands and results: passed cleanly to the direct call.
+    (resume $cont-binary
+      (i32.const 1)
+      (i32.const 2)
+      (cont.new $cont-binary (ref.func $pure-binary))
+    )
+  )
+
+  ;; NO-TNH:      (func $test-fallthrough-block (type $sig-none)
+  ;; NO-TNH-NEXT:  (call $pure)
+  ;; NO-TNH-NEXT: )
+  ;; TNH:      (func $test-fallthrough-block (type $sig-none)
+  ;; TNH-NEXT:  (call $pure)
+  ;; TNH-NEXT: )
+  ;; VACUUM:      (func $test-fallthrough-block (type $sig-none)
+  ;; VACUUM-NEXT:  (nop)
+  ;; VACUUM-NEXT: )
+  (func $test-fallthrough-block
+    ;; Fallthrough cases: straight-line blocks and ref.cast.
+    (resume $cont-none
+      (block (result (ref $cont-none))
+        (cont.new $cont-none
+          (block (result (ref $sig-none))
+            (ref.func $pure)
+          )
+        )
+      )
+    )
+  )
+
+  ;; NO-TNH:      (func $test-fallthrough-cast (type $sig-none)
+  ;; NO-TNH-NEXT:  (call $pure)
+  ;; NO-TNH-NEXT: )
+  ;; TNH:      (func $test-fallthrough-cast (type $sig-none)
+  ;; TNH-NEXT:  (call $pure)
+  ;; TNH-NEXT: )
+  ;; VACUUM:      (func $test-fallthrough-cast (type $sig-none)
+  ;; VACUUM-NEXT:  (nop)
+  ;; VACUUM-NEXT: )
+  (func $test-fallthrough-cast
+    (resume $cont-none
+      (cont.new $cont-none
+        (ref.cast (ref $sig-none)
+          (ref.func $pure)
+        )
+      )
+    )
+  )
+
+  ;; NO-TNH:      (func $test-tee (type $10) (result (ref $cont-none))
+  ;; NO-TNH-NEXT:  (local $c (ref null $cont-none))
+  ;; NO-TNH-NEXT:  (resume $cont-none
+  ;; NO-TNH-NEXT:   (local.tee $c
+  ;; NO-TNH-NEXT:    (cont.new $cont-none
+  ;; NO-TNH-NEXT:     (ref.func $pure)
+  ;; NO-TNH-NEXT:    )
+  ;; NO-TNH-NEXT:   )
+  ;; NO-TNH-NEXT:  )
+  ;; NO-TNH-NEXT:  (ref.as_non_null
+  ;; NO-TNH-NEXT:   (local.get $c)
+  ;; NO-TNH-NEXT:  )
+  ;; NO-TNH-NEXT: )
+  ;; TNH:      (func $test-tee (type $10) (result (ref $cont-none))
+  ;; TNH-NEXT:  (local $c (ref null $cont-none))
+  ;; TNH-NEXT:  (local $1 (ref null $cont-none))
+  ;; TNH-NEXT:  (block
+  ;; TNH-NEXT:   (local.set $1
+  ;; TNH-NEXT:    (local.tee $c
+  ;; TNH-NEXT:     (cont.new $cont-none
+  ;; TNH-NEXT:      (ref.func $pure)
+  ;; TNH-NEXT:     )
+  ;; TNH-NEXT:    )
+  ;; TNH-NEXT:   )
+  ;; TNH-NEXT:   (call $pure)
+  ;; TNH-NEXT:  )
+  ;; TNH-NEXT:  (ref.as_non_null
+  ;; TNH-NEXT:   (local.get $c)
+  ;; TNH-NEXT:  )
+  ;; TNH-NEXT: )
+  ;; VACUUM:      (func $test-tee (type $10) (result (ref $cont-none))
+  ;; VACUUM-NEXT:  (local $c (ref null $cont-none))
+  ;; VACUUM-NEXT:  (resume $cont-none
+  ;; VACUUM-NEXT:   (local.tee $c
+  ;; VACUUM-NEXT:    (cont.new $cont-none
+  ;; VACUUM-NEXT:     (ref.func $pure)
+  ;; VACUUM-NEXT:    )
+  ;; VACUUM-NEXT:   )
+  ;; VACUUM-NEXT:  )
+  ;; VACUUM-NEXT:  (ref.as_non_null
+  ;; VACUUM-NEXT:   (local.get $c)
+  ;; VACUUM-NEXT:  )
+  ;; VACUUM-NEXT: )
+  (func $test-tee (result (ref $cont-none))
+    ;; trapsNeverHappen: local.tee is only looked through with TNH.
+    (local $c (ref null $cont-none))
+    (resume $cont-none
+      (local.tee $c
+        (cont.new $cont-none (ref.func $pure))
+      )
+    )
+    (ref.as_non_null (local.get $c))
+  )
+
+  ;; NO-TNH:      (func $test-tee-params (type $11) (result (ref $cont-binary))
+  ;; NO-TNH-NEXT:  (local $c (ref null $cont-binary))
+  ;; NO-TNH-NEXT:  (drop
+  ;; NO-TNH-NEXT:   (resume $cont-binary
+  ;; NO-TNH-NEXT:    (i32.const 1)
+  ;; NO-TNH-NEXT:    (i32.const 2)
+  ;; NO-TNH-NEXT:    (local.tee $c
+  ;; NO-TNH-NEXT:     (cont.new $cont-binary
+  ;; NO-TNH-NEXT:      (ref.func $pure-binary)
+  ;; NO-TNH-NEXT:     )
+  ;; NO-TNH-NEXT:    )
+  ;; NO-TNH-NEXT:   )
+  ;; NO-TNH-NEXT:  )
+  ;; NO-TNH-NEXT:  (ref.as_non_null
+  ;; NO-TNH-NEXT:   (local.get $c)
+  ;; NO-TNH-NEXT:  )
+  ;; NO-TNH-NEXT: )
+  ;; TNH:      (func $test-tee-params (type $11) (result (ref $cont-binary))
+  ;; TNH-NEXT:  (local $c (ref null $cont-binary))
+  ;; TNH-NEXT:  (local $1 (ref null $cont-binary))
+  ;; TNH-NEXT:  (drop
+  ;; TNH-NEXT:   (block (result i32)
+  ;; TNH-NEXT:    (local.set $1
+  ;; TNH-NEXT:     (local.tee $c
+  ;; TNH-NEXT:      (cont.new $cont-binary
+  ;; TNH-NEXT:       (ref.func $pure-binary)
+  ;; TNH-NEXT:      )
+  ;; TNH-NEXT:     )
+  ;; TNH-NEXT:    )
+  ;; TNH-NEXT:    (call $pure-binary
+  ;; TNH-NEXT:     (i32.const 1)
+  ;; TNH-NEXT:     (i32.const 2)
+  ;; TNH-NEXT:    )
+  ;; TNH-NEXT:   )
+  ;; TNH-NEXT:  )
+  ;; TNH-NEXT:  (ref.as_non_null
+  ;; TNH-NEXT:   (local.get $c)
+  ;; TNH-NEXT:  )
+  ;; TNH-NEXT: )
+  ;; VACUUM:      (func $test-tee-params (type $11) (result (ref $cont-binary))
+  ;; VACUUM-NEXT:  (local $c (ref null $cont-binary))
+  ;; VACUUM-NEXT:  (drop
+  ;; VACUUM-NEXT:   (resume $cont-binary
+  ;; VACUUM-NEXT:    (i32.const 1)
+  ;; VACUUM-NEXT:    (i32.const 2)
+  ;; VACUUM-NEXT:    (local.tee $c
+  ;; VACUUM-NEXT:     (cont.new $cont-binary
+  ;; VACUUM-NEXT:      (ref.func $pure-binary)
+  ;; VACUUM-NEXT:     )
+  ;; VACUUM-NEXT:    )
+  ;; VACUUM-NEXT:   )
+  ;; VACUUM-NEXT:  )
+  ;; VACUUM-NEXT:  (ref.as_non_null
+  ;; VACUUM-NEXT:   (local.get $c)
+  ;; VACUUM-NEXT:  )
+  ;; VACUUM-NEXT: )
+  (func $test-tee-params (result (ref $cont-binary))
+    ;; trapsNeverHappen: local.tee with operands is only looked through with
+    ;; TNH.
+    (local $c (ref null $cont-binary))
+    (drop
+      (resume $cont-binary
+        (i32.const 1)
+        (i32.const 2)
+        (local.tee $c
+          (cont.new $cont-binary (ref.func $pure-binary))
+        )
+      )
+    )
+    (ref.as_non_null (local.get $c))
+  )
+
+  ;; NO-TNH:      (func $test-tee-func (type $12) (result (ref $sig-none))
+  ;; NO-TNH-NEXT:  (local $f (ref null $sig-none))
+  ;; NO-TNH-NEXT:  (local $1 (ref (exact $cont-none)))
+  ;; NO-TNH-NEXT:  (block
+  ;; NO-TNH-NEXT:   (local.set $1
+  ;; NO-TNH-NEXT:    (cont.new $cont-none
+  ;; NO-TNH-NEXT:     (local.tee $f
+  ;; NO-TNH-NEXT:      (ref.func $pure)
+  ;; NO-TNH-NEXT:     )
+  ;; NO-TNH-NEXT:    )
+  ;; NO-TNH-NEXT:   )
+  ;; NO-TNH-NEXT:   (call $pure)
+  ;; NO-TNH-NEXT:  )
+  ;; NO-TNH-NEXT:  (ref.as_non_null
+  ;; NO-TNH-NEXT:   (local.get $f)
+  ;; NO-TNH-NEXT:  )
+  ;; NO-TNH-NEXT: )
+  ;; TNH:      (func $test-tee-func (type $12) (result (ref $sig-none))
+  ;; TNH-NEXT:  (local $f (ref null $sig-none))
+  ;; TNH-NEXT:  (local $1 (ref (exact $cont-none)))
+  ;; TNH-NEXT:  (block
+  ;; TNH-NEXT:   (local.set $1
+  ;; TNH-NEXT:    (cont.new $cont-none
+  ;; TNH-NEXT:     (local.tee $f
+  ;; TNH-NEXT:      (ref.func $pure)
+  ;; TNH-NEXT:     )
+  ;; TNH-NEXT:    )
+  ;; TNH-NEXT:   )
+  ;; TNH-NEXT:   (call $pure)
+  ;; TNH-NEXT:  )
+  ;; TNH-NEXT:  (ref.as_non_null
+  ;; TNH-NEXT:   (local.get $f)
+  ;; TNH-NEXT:  )
+  ;; TNH-NEXT: )
+  ;; VACUUM:      (func $test-tee-func (type $12) (result (ref $sig-none))
+  ;; VACUUM-NEXT:  (local $f (ref null $sig-none))
+  ;; VACUUM-NEXT:  (local $1 (ref (exact $cont-none)))
+  ;; VACUUM-NEXT:  (local.set $1
+  ;; VACUUM-NEXT:   (cont.new $cont-none
+  ;; VACUUM-NEXT:    (local.tee $f
+  ;; VACUUM-NEXT:     (ref.func $pure)
+  ;; VACUUM-NEXT:    )
+  ;; VACUUM-NEXT:   )
+  ;; VACUUM-NEXT:  )
+  ;; VACUUM-NEXT:  (ref.as_non_null
+  ;; VACUUM-NEXT:   (local.get $f)
+  ;; VACUUM-NEXT:  )
+  ;; VACUUM-NEXT: )
+  (func $test-tee-func (result (ref $sig-none))
+    ;; Now the tee is on the ref.func. We can look through it with or without
+    ;; TNH.
+    (local $f (ref null $sig-none))
+    (resume $cont-none
+      (cont.new $cont-none
+        (local.tee $f (ref.func $pure))
+      )
+    )
+    (ref.as_non_null (local.get $f))
+  )
+
+  ;; NO-TNH:      (func $test-negative-suspend (type $sig-none)
+  ;; NO-TNH-NEXT:  (drop
+  ;; NO-TNH-NEXT:   (block $on-suspend (result (ref $cont-none))
+  ;; NO-TNH-NEXT:    (resume $cont-none (on $tag $on-suspend)
+  ;; NO-TNH-NEXT:     (cont.new $cont-none
+  ;; NO-TNH-NEXT:      (ref.func $suspending)
+  ;; NO-TNH-NEXT:     )
+  ;; NO-TNH-NEXT:    )
+  ;; NO-TNH-NEXT:    (unreachable)
+  ;; NO-TNH-NEXT:   )
+  ;; NO-TNH-NEXT:  )
+  ;; NO-TNH-NEXT: )
+  ;; TNH:      (func $test-negative-suspend (type $sig-none)
+  ;; TNH-NEXT:  (drop
+  ;; TNH-NEXT:   (block $on-suspend (result (ref $cont-none))
+  ;; TNH-NEXT:    (resume $cont-none (on $tag $on-suspend)
+  ;; TNH-NEXT:     (cont.new $cont-none
+  ;; TNH-NEXT:      (ref.func $suspending)
+  ;; TNH-NEXT:     )
+  ;; TNH-NEXT:    )
+  ;; TNH-NEXT:    (unreachable)
+  ;; TNH-NEXT:   )
+  ;; TNH-NEXT:  )
+  ;; TNH-NEXT: )
+  ;; VACUUM:      (func $test-negative-suspend (type $sig-none)
+  ;; VACUUM-NEXT:  (drop
+  ;; VACUUM-NEXT:   (block $on-suspend (result (ref $cont-none))
+  ;; VACUUM-NEXT:    (resume $cont-none (on $tag $on-suspend)
+  ;; VACUUM-NEXT:     (cont.new $cont-none
+  ;; VACUUM-NEXT:      (ref.func $suspending)
+  ;; VACUUM-NEXT:     )
+  ;; VACUUM-NEXT:    )
+  ;; VACUUM-NEXT:    (unreachable)
+  ;; VACUUM-NEXT:   )
+  ;; VACUUM-NEXT:  )
+  ;; VACUUM-NEXT: )
+  (func $test-negative-suspend
+    ;; Negative test: continuation function that suspends cannot be converted.
+    (block $on-suspend (result (ref $cont-none))
+      (resume $cont-none (on $tag $on-suspend)
+        (cont.new $cont-none (ref.func $suspending))
+      )
+      (unreachable)
+    )
+    (drop)
+  )
+
+  ;; NO-TNH:      (func $test-negative-transitive-suspend (type $sig-none)
+  ;; NO-TNH-NEXT:  (drop
+  ;; NO-TNH-NEXT:   (block $on-suspend (result (ref $cont-none))
+  ;; NO-TNH-NEXT:    (resume $cont-none (on $tag $on-suspend)
+  ;; NO-TNH-NEXT:     (cont.new $cont-none
+  ;; NO-TNH-NEXT:      (ref.func $caller-of-suspending)
+  ;; NO-TNH-NEXT:     )
+  ;; NO-TNH-NEXT:    )
+  ;; NO-TNH-NEXT:    (unreachable)
+  ;; NO-TNH-NEXT:   )
+  ;; NO-TNH-NEXT:  )
+  ;; NO-TNH-NEXT: )
+  ;; TNH:      (func $test-negative-transitive-suspend (type $sig-none)
+  ;; TNH-NEXT:  (drop
+  ;; TNH-NEXT:   (block $on-suspend (result (ref $cont-none))
+  ;; TNH-NEXT:    (resume $cont-none (on $tag $on-suspend)
+  ;; TNH-NEXT:     (cont.new $cont-none
+  ;; TNH-NEXT:      (ref.func $caller-of-suspending)
+  ;; TNH-NEXT:     )
+  ;; TNH-NEXT:    )
+  ;; TNH-NEXT:    (unreachable)
+  ;; TNH-NEXT:   )
+  ;; TNH-NEXT:  )
+  ;; TNH-NEXT: )
+  ;; VACUUM:      (func $test-negative-transitive-suspend (type $sig-none)
+  ;; VACUUM-NEXT:  (drop
+  ;; VACUUM-NEXT:   (block $on-suspend (result (ref $cont-none))
+  ;; VACUUM-NEXT:    (resume $cont-none (on $tag $on-suspend)
+  ;; VACUUM-NEXT:     (cont.new $cont-none
+  ;; VACUUM-NEXT:      (ref.func $caller-of-suspending)
+  ;; VACUUM-NEXT:     )
+  ;; VACUUM-NEXT:    )
+  ;; VACUUM-NEXT:    (unreachable)
+  ;; VACUUM-NEXT:   )
+  ;; VACUUM-NEXT:  )
+  ;; VACUUM-NEXT: )
+  (func $test-negative-transitive-suspend
+    ;; Negative test: continuation function calling a suspending function.
+    (block $on-suspend (result (ref $cont-none))
+      (resume $cont-none (on $tag $on-suspend)
+        (cont.new $cont-none (ref.func $caller-of-suspending))
+      )
+      (unreachable)
+    )
+    (drop)
+  )
+
+  ;; NO-TNH:      (func $test-same-sig (type $2) (result i32)
+  ;; NO-TNH-NEXT:  (call $same-sig-pure
+  ;; NO-TNH-NEXT:   (i32.const 42)
+  ;; NO-TNH-NEXT:  )
+  ;; NO-TNH-NEXT: )
+  ;; TNH:      (func $test-same-sig (type $2) (result i32)
+  ;; TNH-NEXT:  (call $same-sig-pure
+  ;; TNH-NEXT:   (i32.const 42)
+  ;; TNH-NEXT:  )
+  ;; TNH-NEXT: )
+  ;; VACUUM:      (func $test-same-sig (type $2) (result i32)
+  ;; VACUUM-NEXT:  (call $same-sig-pure
+  ;; VACUUM-NEXT:   (i32.const 42)
+  ;; VACUUM-NEXT:  )
+  ;; VACUUM-NEXT: )
+  (func $test-same-sig (result i32)
+    ;; Precision test: function $f does not suspend, but another function with
+    ;; the same signature does. Verify $f is still converted.
+    (resume $cont-unary
+      (i32.const 42)
+      (cont.new $cont-unary (ref.func $same-sig-pure))
+    )
+  )
+
+  ;; NO-TNH:      (func $test-eval-order (type $2) (result i32)
+  ;; NO-TNH-NEXT:  (local $0 i32)
+  ;; NO-TNH-NEXT:  (local $1 i32)
+  ;; NO-TNH-NEXT:  (local $2 (ref $cont-binary))
+  ;; NO-TNH-NEXT:  (local.set $0
+  ;; NO-TNH-NEXT:   (call $side-effect-1)
+  ;; NO-TNH-NEXT:  )
+  ;; NO-TNH-NEXT:  (local.set $1
+  ;; NO-TNH-NEXT:   (call $side-effect-2)
+  ;; NO-TNH-NEXT:  )
+  ;; NO-TNH-NEXT:  (local.set $2
+  ;; NO-TNH-NEXT:   (block (result (ref $cont-binary))
+  ;; NO-TNH-NEXT:    (call $side-effect-3)
+  ;; NO-TNH-NEXT:    (cont.new $cont-binary
+  ;; NO-TNH-NEXT:     (ref.func $pure-binary)
+  ;; NO-TNH-NEXT:    )
+  ;; NO-TNH-NEXT:   )
+  ;; NO-TNH-NEXT:  )
+  ;; NO-TNH-NEXT:  (call $pure-binary
+  ;; NO-TNH-NEXT:   (local.get $0)
+  ;; NO-TNH-NEXT:   (local.get $1)
+  ;; NO-TNH-NEXT:  )
+  ;; NO-TNH-NEXT: )
+  ;; TNH:      (func $test-eval-order (type $2) (result i32)
+  ;; TNH-NEXT:  (local $0 i32)
+  ;; TNH-NEXT:  (local $1 i32)
+  ;; TNH-NEXT:  (local $2 (ref $cont-binary))
+  ;; TNH-NEXT:  (local.set $0
+  ;; TNH-NEXT:   (call $side-effect-1)
+  ;; TNH-NEXT:  )
+  ;; TNH-NEXT:  (local.set $1
+  ;; TNH-NEXT:   (call $side-effect-2)
+  ;; TNH-NEXT:  )
+  ;; TNH-NEXT:  (local.set $2
+  ;; TNH-NEXT:   (block (result (ref $cont-binary))
+  ;; TNH-NEXT:    (call $side-effect-3)
+  ;; TNH-NEXT:    (cont.new $cont-binary
+  ;; TNH-NEXT:     (ref.func $pure-binary)
+  ;; TNH-NEXT:    )
+  ;; TNH-NEXT:   )
+  ;; TNH-NEXT:  )
+  ;; TNH-NEXT:  (call $pure-binary
+  ;; TNH-NEXT:   (local.get $0)
+  ;; TNH-NEXT:   (local.get $1)
+  ;; TNH-NEXT:  )
+  ;; TNH-NEXT: )
+  ;; VACUUM:      (func $test-eval-order (type $2) (result i32)
+  ;; VACUUM-NEXT:  (local $0 i32)
+  ;; VACUUM-NEXT:  (local $1 i32)
+  ;; VACUUM-NEXT:  (local $2 (ref $cont-binary))
+  ;; VACUUM-NEXT:  (local.set $0
+  ;; VACUUM-NEXT:   (call $side-effect-1)
+  ;; VACUUM-NEXT:  )
+  ;; VACUUM-NEXT:  (local.set $1
+  ;; VACUUM-NEXT:   (call $side-effect-2)
+  ;; VACUUM-NEXT:  )
+  ;; VACUUM-NEXT:  (local.set $2
+  ;; VACUUM-NEXT:   (block (result (ref (exact $cont-binary)))
+  ;; VACUUM-NEXT:    (call $side-effect-3)
+  ;; VACUUM-NEXT:    (cont.new $cont-binary
+  ;; VACUUM-NEXT:     (ref.func $pure-binary)
+  ;; VACUUM-NEXT:    )
+  ;; VACUUM-NEXT:   )
+  ;; VACUUM-NEXT:  )
+  ;; VACUUM-NEXT:  (call $pure-binary
+  ;; VACUUM-NEXT:   (local.get $0)
+  ;; VACUUM-NEXT:   (local.get $1)
+  ;; VACUUM-NEXT:  )
+  ;; VACUUM-NEXT: )
+  (func $test-eval-order (result i32)
+    ;; Evaluation order test: side effects in continuation expression execute
+    ;; after operands and before the direct call.
+    (resume $cont-binary
+      (call $side-effect-1)
+      (call $side-effect-2)
+      (block (result (ref $cont-binary))
+        (call $side-effect-3)
+        (cont.new $cont-binary (ref.func $pure-binary))
+      )
+    )
+  )
+
+  ;; NO-TNH:      (func $test-handler-elimination (type $sig-none)
+  ;; NO-TNH-NEXT:  (drop
+  ;; NO-TNH-NEXT:   (block $handler (result (ref $cont-none))
+  ;; NO-TNH-NEXT:    (block
+  ;; NO-TNH-NEXT:     (call $pure)
+  ;; NO-TNH-NEXT:    )
+  ;; NO-TNH-NEXT:    (return)
+  ;; NO-TNH-NEXT:   )
+  ;; NO-TNH-NEXT:  )
+  ;; NO-TNH-NEXT: )
+  ;; TNH:      (func $test-handler-elimination (type $sig-none)
+  ;; TNH-NEXT:  (drop
+  ;; TNH-NEXT:   (block $handler (result (ref $cont-none))
+  ;; TNH-NEXT:    (block
+  ;; TNH-NEXT:     (call $pure)
+  ;; TNH-NEXT:    )
+  ;; TNH-NEXT:    (return)
+  ;; TNH-NEXT:   )
+  ;; TNH-NEXT:  )
+  ;; TNH-NEXT: )
+  ;; VACUUM:      (func $test-handler-elimination (type $sig-none)
+  ;; VACUUM-NEXT:  (nop)
+  ;; VACUUM-NEXT: )
+  (func $test-handler-elimination
+    ;; Handler elimination test: dead handler blocks are removed in full
+    ;; pipeline.
+    (block $handler (result (ref $cont-none))
+      (resume $cont-none (on $tag $handler)
+        (cont.new $cont-none (ref.func $pure))
+      )
+      (return)
+    )
+    (drop)
+  )
+
+  ;; NO-TNH:      (func $test-unreachable-operand (type $sig-none)
+  ;; NO-TNH-NEXT:  (drop
+  ;; NO-TNH-NEXT:   (resume $cont-binary
+  ;; NO-TNH-NEXT:    (unreachable)
+  ;; NO-TNH-NEXT:    (i32.const 1)
+  ;; NO-TNH-NEXT:    (cont.new $cont-binary
+  ;; NO-TNH-NEXT:     (ref.func $pure-binary)
+  ;; NO-TNH-NEXT:    )
+  ;; NO-TNH-NEXT:   )
+  ;; NO-TNH-NEXT:  )
+  ;; NO-TNH-NEXT: )
+  ;; TNH:      (func $test-unreachable-operand (type $sig-none)
+  ;; TNH-NEXT:  (drop
+  ;; TNH-NEXT:   (resume $cont-binary
+  ;; TNH-NEXT:    (unreachable)
+  ;; TNH-NEXT:    (i32.const 1)
+  ;; TNH-NEXT:    (cont.new $cont-binary
+  ;; TNH-NEXT:     (ref.func $pure-binary)
+  ;; TNH-NEXT:    )
+  ;; TNH-NEXT:   )
+  ;; TNH-NEXT:  )
+  ;; TNH-NEXT: )
+  ;; VACUUM:      (func $test-unreachable-operand (type $sig-none)
+  ;; VACUUM-NEXT:  (drop
+  ;; VACUUM-NEXT:   (resume $cont-binary
+  ;; VACUUM-NEXT:    (unreachable)
+  ;; VACUUM-NEXT:    (i32.const 1)
+  ;; VACUUM-NEXT:    (cont.new $cont-binary
+  ;; VACUUM-NEXT:     (ref.func $pure-binary)
+  ;; VACUUM-NEXT:    )
+  ;; VACUUM-NEXT:   )
+  ;; VACUUM-NEXT:  )
+  ;; VACUUM-NEXT: )
+  (func $test-unreachable-operand
+    ;; Unreachable operands or continuation: resume is unreachable, left for
+    ;; DCE.
+    (resume $cont-binary
+      (unreachable)
+      (i32.const 1)
+      (cont.new $cont-binary (ref.func $pure-binary))
+    )
+    (drop)
+  )
+
+  ;; NO-TNH:      (func $test-unreachable-cont (type $sig-none)
+  ;; NO-TNH-NEXT:  (block ;; (replaces unreachable Resume we can't emit)
+  ;; NO-TNH-NEXT:   (drop
+  ;; NO-TNH-NEXT:    (unreachable)
+  ;; NO-TNH-NEXT:   )
+  ;; NO-TNH-NEXT:   (unreachable)
+  ;; NO-TNH-NEXT:  )
+  ;; NO-TNH-NEXT: )
+  ;; TNH:      (func $test-unreachable-cont (type $sig-none)
+  ;; TNH-NEXT:  (block ;; (replaces unreachable Resume we can't emit)
+  ;; TNH-NEXT:   (drop
+  ;; TNH-NEXT:    (unreachable)
+  ;; TNH-NEXT:   )
+  ;; TNH-NEXT:   (unreachable)
+  ;; TNH-NEXT:  )
+  ;; TNH-NEXT: )
+  ;; VACUUM:      (func $test-unreachable-cont (type $sig-none)
+  ;; VACUUM-NEXT:  (block ;; (replaces unreachable Resume we can't emit)
+  ;; VACUUM-NEXT:   (drop
+  ;; VACUUM-NEXT:    (unreachable)
+  ;; VACUUM-NEXT:   )
+  ;; VACUUM-NEXT:   (unreachable)
+  ;; VACUUM-NEXT:  )
+  ;; VACUUM-NEXT: )
+  (func $test-unreachable-cont
+    ;; Unreachable continuation: resume is unreachable, left for DCE.
+    (resume $cont-none
+      (unreachable)
+    )
+  )
+
+  ;; NO-TNH:      (func $test-negative-imported (type $sig-none)
+  ;; NO-TNH-NEXT:  (resume $cont-none
+  ;; NO-TNH-NEXT:   (cont.new $cont-none
+  ;; NO-TNH-NEXT:    (ref.func $imported)
+  ;; NO-TNH-NEXT:   )
+  ;; NO-TNH-NEXT:  )
+  ;; NO-TNH-NEXT: )
+  ;; TNH:      (func $test-negative-imported (type $sig-none)
+  ;; TNH-NEXT:  (resume $cont-none
+  ;; TNH-NEXT:   (cont.new $cont-none
+  ;; TNH-NEXT:    (ref.func $imported)
+  ;; TNH-NEXT:   )
+  ;; TNH-NEXT:  )
+  ;; TNH-NEXT: )
+  ;; VACUUM:      (func $test-negative-imported (type $sig-none)
+  ;; VACUUM-NEXT:  (resume $cont-none
+  ;; VACUUM-NEXT:   (cont.new $cont-none
+  ;; VACUUM-NEXT:    (ref.func $imported)
+  ;; VACUUM-NEXT:   )
+  ;; VACUUM-NEXT:  )
+  ;; VACUUM-NEXT: )
+  (func $test-negative-imported
+    ;; Negative test: continuation function is imported and cannot be proven
+    ;; non-suspending.
+    (resume $cont-none
+      (cont.new $cont-none (ref.func $imported))
+    )
+  )
+
+  ;; NO-TNH:      (func $test-handler-switch (type $sig-none)
+  ;; NO-TNH-NEXT:  (call $pure)
+  ;; NO-TNH-NEXT: )
+  ;; TNH:      (func $test-handler-switch (type $sig-none)
+  ;; TNH-NEXT:  (call $pure)
+  ;; TNH-NEXT: )
+  ;; VACUUM:      (func $test-handler-switch (type $sig-none)
+  ;; VACUUM-NEXT:  (nop)
+  ;; VACUUM-NEXT: )
+  (func $test-handler-switch
+    ;; Handler elimination test: switch handlers are also eliminated when
+    ;; directizing.
+    (resume $cont-none (on $tag switch)
+      (cont.new $cont-none (ref.func $pure))
+    )
+  )
+
+  ;; NO-TNH:      (func $test-eval-order-no-operands (type $sig-none)
+  ;; NO-TNH-NEXT:  (local $0 (ref $cont-none))
+  ;; NO-TNH-NEXT:  (local.set $0
+  ;; NO-TNH-NEXT:   (block (result (ref $cont-none))
+  ;; NO-TNH-NEXT:    (call $side-effect-3)
+  ;; NO-TNH-NEXT:    (cont.new $cont-none
+  ;; NO-TNH-NEXT:     (ref.func $pure)
+  ;; NO-TNH-NEXT:    )
+  ;; NO-TNH-NEXT:   )
+  ;; NO-TNH-NEXT:  )
+  ;; NO-TNH-NEXT:  (call $pure)
+  ;; NO-TNH-NEXT: )
+  ;; TNH:      (func $test-eval-order-no-operands (type $sig-none)
+  ;; TNH-NEXT:  (local $0 (ref $cont-none))
+  ;; TNH-NEXT:  (local.set $0
+  ;; TNH-NEXT:   (block (result (ref $cont-none))
+  ;; TNH-NEXT:    (call $side-effect-3)
+  ;; TNH-NEXT:    (cont.new $cont-none
+  ;; TNH-NEXT:     (ref.func $pure)
+  ;; TNH-NEXT:    )
+  ;; TNH-NEXT:   )
+  ;; TNH-NEXT:  )
+  ;; TNH-NEXT:  (call $pure)
+  ;; TNH-NEXT: )
+  ;; VACUUM:      (func $test-eval-order-no-operands (type $sig-none)
+  ;; VACUUM-NEXT:  (local $0 (ref $cont-none))
+  ;; VACUUM-NEXT:  (local.set $0
+  ;; VACUUM-NEXT:   (block (result (ref (exact $cont-none)))
+  ;; VACUUM-NEXT:    (call $side-effect-3)
+  ;; VACUUM-NEXT:    (cont.new $cont-none
+  ;; VACUUM-NEXT:     (ref.func $pure)
+  ;; VACUUM-NEXT:    )
+  ;; VACUUM-NEXT:   )
+  ;; VACUUM-NEXT:  )
+  ;; VACUUM-NEXT: )
+  (func $test-eval-order-no-operands
+    ;; Evaluation order test: side effects in continuation expression execute
+    ;; before the direct call even when there are no operands.
+    (resume $cont-none
+      (block (result (ref $cont-none))
+        (call $side-effect-3)
+        (cont.new $cont-none (ref.func $pure))
+      )
+    )
+  )
+)
diff --git a/test/lit/passes/optimize-instructions-struct-rmw.wast b/test/lit/passes/optimize-instructions-struct-rmw.wast
index 19893460361..cec1320c45d 100644
--- a/test/lit/passes/optimize-instructions-struct-rmw.wast
+++ b/test/lit/passes/optimize-instructions-struct-rmw.wast
@@ -1798,24 +1798,32 @@
 
   ;; CHECK:      (func $acquire-load-after (type $2) (param $struct (ref $struct)) (param $array (ref $array)) (result i32)
   ;; CHECK-NEXT:  (block $l (result i32)
-  ;; CHECK-NEXT:   (struct.atomic.rmw.cmpxchg acqrel acqrel $struct 0
-  ;; CHECK-NEXT:    (local.get $struct)
-  ;; CHECK-NEXT:    (struct.get $struct 0
-  ;; CHECK-NEXT:     (local.get $struct)
-  ;; CHECK-NEXT:    )
-  ;; CHECK-NEXT:    (br_if $l
-  ;; CHECK-NEXT:     (struct.get $struct 0
-  ;; CHECK-NEXT:      (local.get $struct)
-  ;; CHECK-NEXT:     )
-  ;; CHECK-NEXT:     (block (result i32)
+  ;; CHECK-NEXT:   (struct.atomic.get acqrel $struct 0
+  ;; CHECK-NEXT:    (block (result (ref $struct))
+  ;; CHECK-NEXT:     (block
   ;; CHECK-NEXT:      (drop
-  ;; CHECK-NEXT:       (array.atomic.get acqrel $array
-  ;; CHECK-NEXT:        (local.get $array)
-  ;; CHECK-NEXT:        (i32.const 0)
+  ;; CHECK-NEXT:       (struct.get $struct 0
+  ;; CHECK-NEXT:        (local.get $struct)
+  ;; CHECK-NEXT:       )
+  ;; CHECK-NEXT:      )
+  ;; CHECK-NEXT:      (drop
+  ;; CHECK-NEXT:       (br_if $l
+  ;; CHECK-NEXT:        (struct.get $struct 0
+  ;; CHECK-NEXT:         (local.get $struct)
+  ;; CHECK-NEXT:        )
+  ;; CHECK-NEXT:        (block (result i32)
+  ;; CHECK-NEXT:         (drop
+  ;; CHECK-NEXT:          (array.atomic.get acqrel $array
+  ;; CHECK-NEXT:           (local.get $array)
+  ;; CHECK-NEXT:           (i32.const 0)
+  ;; CHECK-NEXT:          )
+  ;; CHECK-NEXT:         )
+  ;; CHECK-NEXT:         (i32.const 0)
+  ;; CHECK-NEXT:        )
   ;; CHECK-NEXT:       )
   ;; CHECK-NEXT:      )
-  ;; CHECK-NEXT:      (i32.const 0)
   ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:     (local.get $struct)
   ;; CHECK-NEXT:    )
   ;; CHECK-NEXT:   )
   ;; CHECK-NEXT:  )
@@ -1831,11 +1839,6 @@
           ;; The condition is executed after the RHS value is computed, so its
           ;; effects cannot affect the values seen by the cmpxchg and can never
           ;; block optimization.
-          ;; TODO: getImmediateFallthroughPtr "helpfully" only allows
-          ;; fallthrough via br_if when the value and condition can be
-          ;; reordered. In this case the value and condition _can_ be reordered,
-          ;; but the reordering check is currently symmetric, so the
-          ;; optimization is still blocked.
           (block (result i32)
             (drop (array.atomic.get acqrel $array (local.get $array) (i32.const 0)))
             (i32.const 0)
diff --git a/test/lit/passes/optimize-instructions-waitqueue.wast b/test/lit/passes/optimize-instructions-waitqueue.wast
new file mode 100644
index 00000000000..8abe1860daa
--- /dev/null
+++ b/test/lit/passes/optimize-instructions-waitqueue.wast
@@ -0,0 +1,70 @@
+;; NOTE: Assertions have been generated by update_lit_checks.py and should not be edited.
+
+;; RUN: wasm-opt %s -all --optimize-instructions -S -o - | filecheck %s
+
+(module
+  ;; CHECK:      (type $shared (shared (struct (field (mut i32)))))
+  (type $shared (shared (struct (field (mut i32)))))
+
+  ;; CHECK:      (func $select-struct-wait (type $1) (param $x (ref $shared)) (param $wq (ref (shared waitqueue))) (result i32)
+  ;; CHECK-NEXT:  (select
+  ;; CHECK-NEXT:   (struct.wait $shared 0
+  ;; CHECK-NEXT:    (local.get $x)
+  ;; CHECK-NEXT:    (local.get $wq)
+  ;; CHECK-NEXT:    (i32.const 0)
+  ;; CHECK-NEXT:    (i64.const -1)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (struct.wait $shared 0
+  ;; CHECK-NEXT:    (local.get $x)
+  ;; CHECK-NEXT:    (local.get $wq)
+  ;; CHECK-NEXT:    (i32.const 0)
+  ;; CHECK-NEXT:    (i64.const -1)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (i32.const 1)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $select-struct-wait (param $x (ref $shared)) (param $wq (ref (shared waitqueue))) (result i32)
+    (select
+      (struct.wait $shared 0
+        (local.get $x)
+        (local.get $wq)
+        (i32.const 0)
+        (i64.const -1)
+      )
+      (struct.wait $shared 0
+        (local.get $x)
+        (local.get $wq)
+        (i32.const 0)
+        (i64.const -1)
+      )
+      (i32.const 1)
+    )
+  )
+
+  ;; CHECK:      (func $select-waitqueue-notify (type $2) (param $wq (ref (shared waitqueue))) (result i32)
+  ;; CHECK-NEXT:  (select
+  ;; CHECK-NEXT:   (waitqueue.notify
+  ;; CHECK-NEXT:    (local.get $wq)
+  ;; CHECK-NEXT:    (i32.const 1)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (waitqueue.notify
+  ;; CHECK-NEXT:    (local.get $wq)
+  ;; CHECK-NEXT:    (i32.const 1)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (i32.const 1)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $select-waitqueue-notify (param $wq (ref (shared waitqueue))) (result i32)
+    (select
+      (waitqueue.notify
+        (local.get $wq)
+        (i32.const 1)
+      )
+      (waitqueue.notify
+        (local.get $wq)
+        (i32.const 1)
+      )
+      (i32.const 1)
+    )
+  )
+)
diff --git a/test/lit/passes/optimize-instructions_branch-hints-fold.wast b/test/lit/passes/optimize-instructions_branch-hints-fold.wast
index 5d6904f457b..e0ec59bfbd0 100644
--- a/test/lit/passes/optimize-instructions_branch-hints-fold.wast
+++ b/test/lit/passes/optimize-instructions_branch-hints-fold.wast
@@ -12,7 +12,11 @@
 ;; RUN:   | filecheck %s --check-prefix=NO_FO
 
 (module
- ;; CHECK:      (func $conditionals (type $1) (param $x i32) (result i32)
+ ;; CHECK:      (type $struct (struct (field (mut i32))))
+ ;; NO_FO:      (type $struct (struct (field (mut i32))))
+ (type $struct (struct (mut i32)))
+
+ ;; CHECK:      (func $conditionals (type $2) (param $x i32) (result i32)
  ;; CHECK-NEXT:  (@metadata.code.branch_hint "\01")
  ;; CHECK-NEXT:  (if (result i32)
  ;; CHECK-NEXT:   (local.get $x)
@@ -24,7 +28,7 @@
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
- ;; NO_FO:      (func $conditionals (type $1) (param $x i32) (result i32)
+ ;; NO_FO:      (func $conditionals (type $2) (param $x i32) (result i32)
  ;; NO_FO-NEXT:  (@metadata.code.branch_hint "\01")
  ;; NO_FO-NEXT:  (if (result i32)
  ;; NO_FO-NEXT:   (local.get $x)
@@ -52,7 +56,7 @@
   )
  )
 
- ;; CHECK:      (func $still-fold (type $0) (param $x i32) (param $y i32)
+ ;; CHECK:      (func $still-fold (type $1) (param $x i32) (param $y i32)
  ;; CHECK-NEXT:  (@metadata.code.branch_hint "\00")
  ;; CHECK-NEXT:  (if
  ;; CHECK-NEXT:   (local.get $y)
@@ -61,7 +65,7 @@
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
- ;; NO_FO:      (func $still-fold (type $0) (param $x i32) (param $y i32)
+ ;; NO_FO:      (func $still-fold (type $1) (param $x i32) (param $y i32)
  ;; NO_FO-NEXT:  (if
  ;; NO_FO-NEXT:   (local.get $x)
  ;; NO_FO-NEXT:   (then
@@ -110,7 +114,7 @@
   )
  )
 
- ;; CHECK:      (func $yes-fold (type $0) (param $x i32) (param $y i32)
+ ;; CHECK:      (func $yes-fold (type $1) (param $x i32) (param $y i32)
  ;; CHECK-NEXT:  (@metadata.code.branch_hint "\01")
  ;; CHECK-NEXT:  (if
  ;; CHECK-NEXT:   (local.get $y)
@@ -119,7 +123,7 @@
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
- ;; NO_FO:      (func $yes-fold (type $0) (param $x i32) (param $y i32)
+ ;; NO_FO:      (func $yes-fold (type $1) (param $x i32) (param $y i32)
  ;; NO_FO-NEXT:  (if
  ;; NO_FO-NEXT:   (local.get $x)
  ;; NO_FO-NEXT:   (then
@@ -167,7 +171,7 @@
   )
  )
 
- ;; CHECK:      (func $always-fold-select (type $2) (param $x i32) (param $y i32) (result i32)
+ ;; CHECK:      (func $always-fold-select (type $3) (param $x i32) (param $y i32) (result i32)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (local.get $y)
  ;; CHECK-NEXT:  )
@@ -182,7 +186,7 @@
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
- ;; NO_FO:      (func $always-fold-select (type $2) (param $x i32) (param $y i32) (result i32)
+ ;; NO_FO:      (func $always-fold-select (type $3) (param $x i32) (param $y i32) (result i32)
  ;; NO_FO-NEXT:  (local $2 i32)
  ;; NO_FO-NEXT:  (local.set $2
  ;; NO_FO-NEXT:   (@metadata.code.branch_hint "\00")
@@ -230,7 +234,7 @@
   )
  )
 
- ;; CHECK:      (func $ordering (type $3) (param $x i32)
+ ;; CHECK:      (func $ordering (type $4) (param $x i32)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (i32.add
  ;; CHECK-NEXT:    (local.get $x)
@@ -244,7 +248,7 @@
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
- ;; NO_FO:      (func $ordering (type $3) (param $x i32)
+ ;; NO_FO:      (func $ordering (type $4) (param $x i32)
  ;; NO_FO-NEXT:  (drop
  ;; NO_FO-NEXT:   (i32.add
  ;; NO_FO-NEXT:    (local.get $x)
@@ -275,4 +279,32 @@
    )
   )
  )
+
+ ;; CHECK:      (func $struct-set (type $5) (param $ref (ref null $struct)) (param $val i32)
+ ;; CHECK-NEXT:  (struct.set $struct 0
+ ;; CHECK-NEXT:   (local.get $ref)
+ ;; CHECK-NEXT:   (local.get $val)
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT: )
+ ;; NO_FO:      (func $struct-set (type $5) (param $ref (ref null $struct)) (param $val i32)
+ ;; NO_FO-NEXT:  (struct.set $struct 0
+ ;; NO_FO-NEXT:   (ref.as_non_null
+ ;; NO_FO-NEXT:    (local.get $ref)
+ ;; NO_FO-NEXT:   )
+ ;; NO_FO-NEXT:   (local.get $val)
+ ;; NO_FO-NEXT:  )
+ ;; NO_FO-NEXT: )
+ (func $struct-set (param $ref (ref null $struct)) (param $val i32)
+  ;; Normally we can skip the ref.as_non_null because struct.set will trap on
+  ;; null anyway. But when never-fold-or-reorder is passed, we must not move the
+  ;; trap after subsequent children (which might reorder across branch hints, if
+  ;; the struct.set's value had a branch hint).
+  (struct.set $struct 0
+   (ref.as_non_null
+    (local.get $ref)
+   )
+   (local.get $val)
+  )
+ )
 )
+
diff --git a/test/lit/passes/post-emscripten.wast b/test/lit/passes/post-emscripten.wast
index 1369252a9bf..0e1f7662a73 100644
--- a/test/lit/passes/post-emscripten.wast
+++ b/test/lit/passes/post-emscripten.wast
@@ -8,7 +8,7 @@
 ;; to dirive.  One segment is passive and its offset is derived from the
 ;; memory.init instruction.
 
-;; Explictly use a data address that is larger then INT_MAX to verify
+;; Explicitly use a data address that is larger then INT_MAX to verify
 ;; that these offset are correctly interpreted as unsigned.
 
 (module
diff --git a/test/lit/passes/precompute-effects.wast b/test/lit/passes/precompute-effects.wast
index d2709cf3a4d..8bf8715c77c 100644
--- a/test/lit/passes/precompute-effects.wast
+++ b/test/lit/passes/precompute-effects.wast
@@ -16,7 +16,7 @@
  (func $loop
   (local $temp i32)
   ;; We should not try to precompute this loop. If we attempted to replace it
-  ;; with its children, we'd need to handle the effects of chidren properly,
+  ;; with its children, we'd need to handle the effects of children properly,
   ;; which we do not do in this pass.
   (loop
    (local.set $temp
diff --git a/test/lit/passes/precompute-gc-loop.wast b/test/lit/passes/precompute-gc-loop.wast
index d1752f23f5c..5600b6c9b13 100644
--- a/test/lit/passes/precompute-gc-loop.wast
+++ b/test/lit/passes/precompute-gc-loop.wast
@@ -64,7 +64,7 @@
 
    ;; The rest of the code is needed to prevent the testcase from getting
    ;; optimized trivially away. This br should not be optimized away or
-   ;; simplfied - it executes in the first loop iteration but not the second.
+   ;; simplified - it executes in the first loop iteration but not the second.
    (br_if $loop
     (i32.eqz
      (block $block1 (result i32)
diff --git a/test/lit/passes/remove-empty-function-exports.wat b/test/lit/passes/remove-empty-function-exports.wat
new file mode 100644
index 00000000000..e46c5b76015
--- /dev/null
+++ b/test/lit/passes/remove-empty-function-exports.wat
@@ -0,0 +1,55 @@
+;; RUN: wasm-opt %s --all-features --remove-empty-function-exports -S -o - | filecheck %s --check-prefix=REMOVE
+
+(module
+  (import "env" "noop" (func $imported))
+
+  (func $empty)
+  (func $empty-block (block))
+  (func $empty-param (param i32) (nop))
+  (func $empty-used)
+  (func $call-empty
+    (call $empty-used)
+  )
+  (func $nonempty
+    (drop
+      (i32.const 0)
+    )
+  )
+  (func $returns (return))
+
+  (memory $memory 1)
+  (table $table 1 funcref)
+  (global $global i32 (i32.const 0))
+  (tag $tag)
+  (start $nonempty)
+
+  (export "empty" (func $empty))
+  (export "empty-alias" (func $empty))
+  (export "empty-block" (func $empty-block))
+  (export "empty-param" (func $empty-param))
+  (export "empty-used" (func $empty-used))
+  (export "call-empty" (func $call-empty))
+  (export "nonempty" (func $nonempty))
+  (export "imported" (func $imported))
+  (export "returns" (func $returns))
+  (export "memory" (memory $memory))
+  (export "table" (table $table))
+  (export "global" (global $global))
+  (export "tag" (tag $tag))
+)
+
+;; REMOVE-NOT:   (export "empty
+;; REMOVE:       (export "call-empty" (func $call-empty))
+;; REMOVE-NEXT:  (export "nonempty" (func $nonempty))
+;; REMOVE-NEXT:  (export "imported" (func $imported))
+;; REMOVE-NEXT:  (export "returns" (func $returns))
+;; REMOVE-NEXT:  (export "memory" (memory $memory))
+;; REMOVE-NEXT:  (export "table" (table $table))
+;; REMOVE-NEXT:  (export "global" (global $global))
+;; REMOVE-NEXT:  (export "tag" (tag $tag))
+;; REMOVE-NOT:   (export
+;; REMOVE:       (start $nonempty)
+;; REMOVE:       (func $empty (type
+;; REMOVE:       (func $empty-block
+;; REMOVE:       (func $empty-param
+;; REMOVE:       (func $empty-used
diff --git a/test/lit/passes/remove-unused-module-elements_all-features.wast b/test/lit/passes/remove-unused-module-elements_all-features.wast
index 816feb6d7c9..68089ff6119 100644
--- a/test/lit/passes/remove-unused-module-elements_all-features.wast
+++ b/test/lit/passes/remove-unused-module-elements_all-features.wast
@@ -572,7 +572,7 @@
   )
  )
 )
-(module ;; the function uses the table, but all are removeable
+(module ;; the function uses the table, but all are removable
  (type $0 (func (param f64) (result f64)))
  (table 6 6 funcref)
  (func $0 (; 0 ;) (type $0) (param $var$0 f64) (result f64)
diff --git a/test/lit/passes/rse-eh-legacy.wast b/test/lit/passes/rse-eh-legacy.wast
index 6a491242186..f90da4643d4 100644
--- a/test/lit/passes/rse-eh-legacy.wast
+++ b/test/lit/passes/rse-eh-legacy.wast
@@ -794,7 +794,7 @@
         (local.set $x (i32.const 1))
       )
     )
-    ;; The innermost try delegates to $l1, which in turn delgates to $l0, whose
+    ;; The innermost try delegates to $l1, which in turn delegates to $l0, whose
     ;; catch_all runs the same local.set. So this can be dropped.
     (local.set $x (i32.const 1))
   )
diff --git a/test/lit/passes/simplify-locals-atomic-effects.wast b/test/lit/passes/simplify-locals-atomic-effects.wast
index 789446d2bbe..ba6de3e7463 100644
--- a/test/lit/passes/simplify-locals-atomic-effects.wast
+++ b/test/lit/passes/simplify-locals-atomic-effects.wast
@@ -6,6 +6,11 @@
   (type $shared-struct (shared (struct (field (mut i32)))))
   ;; CHECK:      (type $shared-array (shared (array (mut i32))))
 
+  ;; CHECK:      (rec
+  ;; CHECK-NEXT:  (type $struct (descriptor $desc) (struct))
+
+  ;; CHECK:       (type $desc (describes $struct) (struct))
+
   ;; CHECK:      (type $unshared-struct (struct (field (mut i32))))
   (type $unshared-struct (struct (field (mut i32))))
 
@@ -58,7 +63,7 @@
     (local.get $x)
   )
 
-  ;; CHECK:      (func $memory.size-shared-unshared (type $5) (param $unshared (ref null $unshared-struct)) (result i32)
+  ;; CHECK:      (func $memory.size-shared-unshared (type $8) (param $unshared (ref null $unshared-struct)) (result i32)
   ;; CHECK-NEXT:  (local $x i32)
   ;; CHECK-NEXT:  (nop)
   ;; CHECK-NEXT:  (struct.atomic.set $unshared-struct 0
@@ -78,7 +83,7 @@
     (local.get $x)
   )
 
-  ;; CHECK:      (func $memory.size-unshared-unshared (type $5) (param $unshared (ref null $unshared-struct)) (result i32)
+  ;; CHECK:      (func $memory.size-unshared-unshared (type $8) (param $unshared (ref null $unshared-struct)) (result i32)
   ;; CHECK-NEXT:  (local $x i32)
   ;; CHECK-NEXT:  (nop)
   ;; CHECK-NEXT:  (struct.atomic.set $unshared-struct 0
@@ -867,7 +872,7 @@
     (local.get $x)
   )
 
-  ;; CHECK:      (func $write-array-fence (type $6) (param $shared (ref null $shared-array)) (result i32)
+  ;; CHECK:      (func $write-array-fence (type $9) (param $shared (ref null $shared-array)) (result i32)
   ;; CHECK-NEXT:  (local $x i32)
   ;; CHECK-NEXT:  (local.set $x
   ;; CHECK-NEXT:   (block (result i32)
@@ -2092,4 +2097,211 @@
     )
     (local.get $x)
   )
+
+  (rec
+    (type $struct (descriptor $desc) (struct))
+    (type $desc (describes $struct) (struct))
+  )
+
+  ;; CHECK:      (func $ref.cast_desc_eq-read-acquire (type $6) (param $x (ref null $struct)) (param $shared (ref null $shared-struct)) (param $d (ref null $desc)) (result (ref null $struct) (ref null $struct))
+  ;; CHECK-NEXT:  (tuple.make 2
+  ;; CHECK-NEXT:   (ref.cast_desc_eq (ref null $struct)
+  ;; CHECK-NEXT:    (block (result (ref null $struct))
+  ;; CHECK-NEXT:     (drop
+  ;; CHECK-NEXT:      (struct.get $shared-struct 0
+  ;; CHECK-NEXT:       (local.get $shared)
+  ;; CHECK-NEXT:      )
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:     (local.get $x)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:    (block (result (ref null $desc))
+  ;; CHECK-NEXT:     (drop
+  ;; CHECK-NEXT:      (struct.atomic.get acqrel $shared-struct 0
+  ;; CHECK-NEXT:       (local.get $shared)
+  ;; CHECK-NEXT:      )
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:     (local.get $d)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (local.get $x)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $ref.cast_desc_eq-read-acquire (param $x (ref null $struct)) (param $shared (ref null $shared-struct)) (param $d (ref null $desc)) (result (ref null $struct) (ref null $struct))
+    ;; A normal read in `ref` can be ordered after an acquire load in `desc`, so
+    ;; getImmediateFallthroughPtr can look through ref.cast_desc_eq and the
+    ;; redundant local.tee is eliminated.
+    (tuple.make 2
+      (local.tee $x
+        (ref.cast_desc_eq (ref null $struct)
+          (block (result (ref null $struct))
+            (drop
+              (struct.get $shared-struct 0 (local.get $shared))
+            )
+            (local.get $x)
+          )
+          (block (result (ref null $desc))
+            (drop
+              (struct.atomic.get acqrel $shared-struct 0 (local.get $shared))
+            )
+            (local.get $d)
+          )
+        )
+      )
+      (local.get $x)
+    )
+  )
+
+  ;; CHECK:      (func $ref.cast_desc_eq-acquire-read (type $6) (param $x (ref null $struct)) (param $shared (ref null $shared-struct)) (param $d (ref null $desc)) (result (ref null $struct) (ref null $struct))
+  ;; CHECK-NEXT:  (tuple.make 2
+  ;; CHECK-NEXT:   (local.tee $x
+  ;; CHECK-NEXT:    (ref.cast_desc_eq (ref null $struct)
+  ;; CHECK-NEXT:     (block (result (ref null $struct))
+  ;; CHECK-NEXT:      (drop
+  ;; CHECK-NEXT:       (struct.atomic.get acqrel $shared-struct 0
+  ;; CHECK-NEXT:        (local.get $shared)
+  ;; CHECK-NEXT:       )
+  ;; CHECK-NEXT:      )
+  ;; CHECK-NEXT:      (local.get $x)
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:     (block (result (ref null $desc))
+  ;; CHECK-NEXT:      (drop
+  ;; CHECK-NEXT:       (struct.get $shared-struct 0
+  ;; CHECK-NEXT:        (local.get $shared)
+  ;; CHECK-NEXT:       )
+  ;; CHECK-NEXT:      )
+  ;; CHECK-NEXT:      (local.get $d)
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (local.get $x)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $ref.cast_desc_eq-acquire-read (param $x (ref null $struct)) (param $shared (ref null $shared-struct)) (param $d (ref null $desc)) (result (ref null $struct) (ref null $struct))
+    ;; An acquire load in `ref` cannot be ordered after a normal read in `desc`,
+    ;; so getImmediateFallthroughPtr cannot look through ref.cast_desc_eq and
+    ;; the local.tee is preserved.
+    ;; TODO: In this case we are not actually reordering anything, so the
+    ;; effects shouldn't matter.
+    (tuple.make 2
+      (local.tee $x
+        (ref.cast_desc_eq (ref null $struct)
+          (block (result (ref null $struct))
+            (drop
+              (struct.atomic.get acqrel $shared-struct 0 (local.get $shared))
+            )
+            (local.get $x)
+          )
+          (block (result (ref null $desc))
+            (drop
+              (struct.get $shared-struct 0 (local.get $shared))
+            )
+            (local.get $d)
+          )
+        )
+      )
+      (local.get $x)
+    )
+  )
+
+  ;; CHECK:      (func $br_on_cast_desc_eq-read-acquire (type $6) (param $x (ref null $struct)) (param $shared (ref null $shared-struct)) (param $d (ref null $desc)) (result (ref null $struct) (ref null $struct))
+  ;; CHECK-NEXT:  (tuple.make 2
+  ;; CHECK-NEXT:   (block $block (result (ref null $struct))
+  ;; CHECK-NEXT:    (br_on_cast_desc_eq $block (ref null $struct) (ref null $struct)
+  ;; CHECK-NEXT:     (block (result (ref null $struct))
+  ;; CHECK-NEXT:      (drop
+  ;; CHECK-NEXT:       (struct.get $shared-struct 0
+  ;; CHECK-NEXT:        (local.get $shared)
+  ;; CHECK-NEXT:       )
+  ;; CHECK-NEXT:      )
+  ;; CHECK-NEXT:      (local.get $x)
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:     (block (result (ref null $desc))
+  ;; CHECK-NEXT:      (drop
+  ;; CHECK-NEXT:       (struct.atomic.get acqrel $shared-struct 0
+  ;; CHECK-NEXT:        (local.get $shared)
+  ;; CHECK-NEXT:       )
+  ;; CHECK-NEXT:      )
+  ;; CHECK-NEXT:      (local.get $d)
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (local.get $x)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $br_on_cast_desc_eq-read-acquire (param $x (ref null $struct)) (param $shared (ref null $shared-struct)) (param $d (ref null $desc)) (result (ref null $struct) (ref null $struct))
+    ;; Same as in $ref.cast_desc_eq-read-acquire.
+    (tuple.make 2
+      (block $block (result (ref null $struct))
+        (local.tee $x
+          (br_on_cast_desc_eq $block (ref null $struct) (ref null $struct)
+            (block (result (ref null $struct))
+              (drop
+                (struct.get $shared-struct 0 (local.get $shared))
+              )
+              (local.get $x)
+            )
+            (block (result (ref null $desc))
+              (drop
+                (struct.atomic.get acqrel $shared-struct 0 (local.get $shared))
+              )
+              (local.get $d)
+            )
+          )
+        )
+      )
+      (local.get $x)
+    )
+  )
+
+  ;; CHECK:      (func $br_on_cast_desc_eq-acquire-read (type $6) (param $x (ref null $struct)) (param $shared (ref null $shared-struct)) (param $d (ref null $desc)) (result (ref null $struct) (ref null $struct))
+  ;; CHECK-NEXT:  (tuple.make 2
+  ;; CHECK-NEXT:   (block $block (result (ref null $struct))
+  ;; CHECK-NEXT:    (local.tee $x
+  ;; CHECK-NEXT:     (br_on_cast_desc_eq $block (ref null $struct) (ref null $struct)
+  ;; CHECK-NEXT:      (block (result (ref null $struct))
+  ;; CHECK-NEXT:       (drop
+  ;; CHECK-NEXT:        (struct.atomic.get acqrel $shared-struct 0
+  ;; CHECK-NEXT:         (local.get $shared)
+  ;; CHECK-NEXT:        )
+  ;; CHECK-NEXT:       )
+  ;; CHECK-NEXT:       (local.get $x)
+  ;; CHECK-NEXT:      )
+  ;; CHECK-NEXT:      (block (result (ref null $desc))
+  ;; CHECK-NEXT:       (drop
+  ;; CHECK-NEXT:        (struct.get $shared-struct 0
+  ;; CHECK-NEXT:         (local.get $shared)
+  ;; CHECK-NEXT:        )
+  ;; CHECK-NEXT:       )
+  ;; CHECK-NEXT:       (local.get $d)
+  ;; CHECK-NEXT:      )
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (local.get $x)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $br_on_cast_desc_eq-acquire-read (param $x (ref null $struct)) (param $shared (ref null $shared-struct)) (param $d (ref null $desc)) (result (ref null $struct) (ref null $struct))
+    ;; Same as in $ref.cast_desc_eq-acquire-read.
+    (tuple.make 2
+      (block $block (result (ref null $struct))
+        (local.tee $x
+          (br_on_cast_desc_eq $block (ref null $struct) (ref null $struct)
+            (block (result (ref null $struct))
+              (drop
+                (struct.atomic.get acqrel $shared-struct 0 (local.get $shared))
+              )
+              (local.get $x)
+            )
+            (block (result (ref null $desc))
+              (drop
+                (struct.get $shared-struct 0 (local.get $shared))
+              )
+              (local.get $d)
+            )
+          )
+        )
+      )
+      (local.get $x)
+    )
+  )
 )
diff --git a/test/lit/passes/simplify-locals-desc.wast b/test/lit/passes/simplify-locals-desc.wast
index acd99538f40..a58b3980f12 100644
--- a/test/lit/passes/simplify-locals-desc.wast
+++ b/test/lit/passes/simplify-locals-desc.wast
@@ -11,7 +11,13 @@
     (type $desc (describes $struct) (struct))
   )
 
-  ;; CHECK:      (func $test (type $2) (param $ref (ref null $struct)) (result (ref $struct))
+  ;; CHECK:      (type $none (func))
+  (type $none (func))
+
+  ;; CHECK:      (tag $tag (type $none))
+  (tag $tag (type $none))
+
+  ;; CHECK:      (func $test (type $3) (param $ref (ref null $struct)) (result (ref $struct))
   ;; CHECK-NEXT:  (local $temp (ref $desc))
   ;; CHECK-NEXT:  (block $block (result (ref none))
   ;; CHECK-NEXT:   (drop
@@ -49,5 +55,74 @@
       (unreachable)
     )
   )
+
+  ;; CHECK:      (func $br_on_cast_desc_eq_in_block (type $4) (result (ref $struct))
+  ;; CHECK-NEXT:  (local $0 (ref null $desc))
+  ;; CHECK-NEXT:  (local $1 i32)
+  ;; CHECK-NEXT:  (block $out (result (ref $struct))
+  ;; CHECK-NEXT:   (if
+  ;; CHECK-NEXT:    (i32.const 0)
+  ;; CHECK-NEXT:    (then
+  ;; CHECK-NEXT:     (block $block
+  ;; CHECK-NEXT:      (drop
+  ;; CHECK-NEXT:       (block (result i32)
+  ;; CHECK-NEXT:        (drop
+  ;; CHECK-NEXT:         (br_on_cast_desc_eq_fail $out (ref (exact $struct)) (ref $struct)
+  ;; CHECK-NEXT:          (struct.new_default_desc $struct
+  ;; CHECK-NEXT:           (ref.null none)
+  ;; CHECK-NEXT:          )
+  ;; CHECK-NEXT:          (try_table (result (ref $desc)) (catch $tag $block)
+  ;; CHECK-NEXT:           (ref.as_non_null
+  ;; CHECK-NEXT:            (local.get $0)
+  ;; CHECK-NEXT:           )
+  ;; CHECK-NEXT:          )
+  ;; CHECK-NEXT:         )
+  ;; CHECK-NEXT:        )
+  ;; CHECK-NEXT:        (i32.const 0)
+  ;; CHECK-NEXT:       )
+  ;; CHECK-NEXT:      )
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (unreachable)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $br_on_cast_desc_eq_in_block (result (ref $struct))
+    (local $0 (ref null $desc))
+    (local $1 i32)
+    ;; While simplifying locals here, we must be aware that the br_on
+    ;; instruction has a descriptor, and must visit it. If we do not, then we'd
+    ;; see no branches to $block, and move the tee out of it, breaking
+    ;; validation.
+    (block $out (result (ref $struct))
+      (if
+        (i32.const 0)
+        (then
+          (block $block
+            (drop
+              (local.tee $1
+                (block (result i32)
+                  (drop
+                    (br_on_cast_desc_eq_fail $out (ref (exact $struct)) (ref $struct)
+                      (struct.new_default_desc $struct
+                        (ref.null none)
+                      )
+                      (try_table (result (ref $desc)) (catch $tag $block)
+                        (ref.as_non_null
+                          (local.get $0)
+                        )
+                      )
+                    )
+                  )
+                  (i32.const 0)
+                )
+              )
+            )
+          )
+        )
+      )
+      (unreachable)
+    )
+  )
 )
 
diff --git a/test/lit/passes/simplify-locals-gc.wast b/test/lit/passes/simplify-locals-gc.wast
index ba7007a361d..8552f07856f 100644
--- a/test/lit/passes/simplify-locals-gc.wast
+++ b/test/lit/passes/simplify-locals-gc.wast
@@ -409,7 +409,7 @@
   ;; CHECK-NEXT: )
   (func $pick-fallthrough (param $x i32)
     (local $t i32)
-    ;; Similar to the above test wth looking through a cast, but using a non-gc
+    ;; Similar to the above test with looking through a cast, but using a non-gc
     ;; type of fallthrough value.
     (local.set $t
       (block (result i32)
diff --git a/test/lit/passes/stack-ir-eh-legacy.wast b/test/lit/passes/stack-ir-eh-legacy.wast
index 14e53a33a98..a8b30987538 100644
--- a/test/lit/passes/stack-ir-eh-legacy.wast
+++ b/test/lit/passes/stack-ir-eh-legacy.wast
@@ -11,7 +11,6 @@
   ;; CHECK-NEXT:   i32.const 0
   ;; CHECK-NEXT:   throw $e0
   ;; CHECK-NEXT:  catch $e0
-  ;; CHECK-NEXT:   
   ;; CHECK-NEXT:   drop
   ;; CHECK-NEXT:  catch_all
   ;; CHECK-NEXT:   rethrow $l0
diff --git a/test/lit/passes/tail-call-eh.wast b/test/lit/passes/tail-call-eh.wast
new file mode 100644
index 00000000000..1478084a901
--- /dev/null
+++ b/test/lit/passes/tail-call-eh.wast
@@ -0,0 +1,377 @@
+;; NOTE: Assertions have been generated by update_lit_checks.py and should not be edited.
+;; Test tail-call optimization interaction with exception handling and GlobalEffects.
+
+;; RUN: wasm-opt %s --tail-call --enable-tail-call --enable-exception-handling --enable-reference-types -S -o - | filecheck %s --check-prefix=NO-EFFECTS
+;; RUN: wasm-opt %s --generate-global-effects --tail-call --enable-tail-call --enable-exception-handling --enable-reference-types -S -o - | filecheck %s --check-prefix=WITH-EFFECTS
+
+(module
+  ;; NO-EFFECTS:      (tag $e1 (type $0))
+  ;; WITH-EFFECTS:      (tag $e1 (type $0))
+  (tag $e1)
+  ;; NO-EFFECTS:      (tag $e2 (type $0))
+  ;; WITH-EFFECTS:      (tag $e2 (type $0))
+  (tag $e2)
+
+  ;; NO-EFFECTS:      (func $throwing-callee
+  ;; NO-EFFECTS-NEXT:  (throw $e1)
+  ;; NO-EFFECTS-NEXT: )
+  ;; WITH-EFFECTS:      (func $throwing-callee
+  ;; WITH-EFFECTS-NEXT:  (throw $e1)
+  ;; WITH-EFFECTS-NEXT: )
+  (func $throwing-callee
+    (throw $e1)
+  )
+
+  ;; NO-EFFECTS:      (func $throwing-i32-callee (result i32)
+  ;; NO-EFFECTS-NEXT:  (throw $e1)
+  ;; NO-EFFECTS-NEXT: )
+  ;; WITH-EFFECTS:      (func $throwing-i32-callee (result i32)
+  ;; WITH-EFFECTS-NEXT:  (throw $e1)
+  ;; WITH-EFFECTS-NEXT: )
+  (func $throwing-i32-callee (result i32)
+    (throw $e1)
+  )
+
+  ;; NO-EFFECTS:      (func $non-throwing-callee (result i32)
+  ;; NO-EFFECTS-NEXT:  (i32.const 42)
+  ;; NO-EFFECTS-NEXT: )
+  ;; WITH-EFFECTS:      (func $non-throwing-callee (result i32)
+  ;; WITH-EFFECTS-NEXT:  (i32.const 42)
+  ;; WITH-EFFECTS-NEXT: )
+  (func $non-throwing-callee (result i32)
+    (i32.const 42)
+  )
+
+  ;; NO-EFFECTS:      (func $non-throwing-param-callee (param $x i32) (result i32)
+  ;; NO-EFFECTS-NEXT:  (local.get $x)
+  ;; NO-EFFECTS-NEXT: )
+  ;; WITH-EFFECTS:      (func $non-throwing-param-callee (param $x i32) (result i32)
+  ;; WITH-EFFECTS-NEXT:  (local.get $x)
+  ;; WITH-EFFECTS-NEXT: )
+  (func $non-throwing-param-callee (param $x i32) (result i32)
+    (local.get $x)
+  )
+
+  ;; NO-EFFECTS:      (func $caller-throws
+  ;; NO-EFFECTS-NEXT:  (block $catch
+  ;; NO-EFFECTS-NEXT:   (try_table (catch_all $catch)
+  ;; NO-EFFECTS-NEXT:    (call $throwing-callee)
+  ;; NO-EFFECTS-NEXT:   )
+  ;; NO-EFFECTS-NEXT:  )
+  ;; NO-EFFECTS-NEXT: )
+  ;; WITH-EFFECTS:      (func $caller-throws
+  ;; WITH-EFFECTS-NEXT:  (block $catch
+  ;; WITH-EFFECTS-NEXT:   (try_table (catch_all $catch)
+  ;; WITH-EFFECTS-NEXT:    (call $throwing-callee)
+  ;; WITH-EFFECTS-NEXT:   )
+  ;; WITH-EFFECTS-NEXT:  )
+  ;; WITH-EFFECTS-NEXT: )
+  (func $caller-throws
+    ;; Inside try_table, a call that might throw cannot be converted to return_call.
+    (block $catch
+      (try_table (catch_all $catch)
+        (call $throwing-callee)
+      )
+    )
+  )
+
+  ;; NO-EFFECTS:      (func $caller-non-throwing-in-try (result i32)
+  ;; NO-EFFECTS-NEXT:  (block $catch
+  ;; NO-EFFECTS-NEXT:   (return
+  ;; NO-EFFECTS-NEXT:    (try_table (result i32) (catch_all $catch)
+  ;; NO-EFFECTS-NEXT:     (call $non-throwing-callee)
+  ;; NO-EFFECTS-NEXT:    )
+  ;; NO-EFFECTS-NEXT:   )
+  ;; NO-EFFECTS-NEXT:  )
+  ;; NO-EFFECTS-NEXT:  (i32.const 0)
+  ;; NO-EFFECTS-NEXT: )
+  ;; WITH-EFFECTS:      (func $caller-non-throwing-in-try (result i32)
+  ;; WITH-EFFECTS-NEXT:  (block $catch
+  ;; WITH-EFFECTS-NEXT:   (return
+  ;; WITH-EFFECTS-NEXT:    (try_table (catch_all $catch)
+  ;; WITH-EFFECTS-NEXT:     (return_call $non-throwing-callee)
+  ;; WITH-EFFECTS-NEXT:    )
+  ;; WITH-EFFECTS-NEXT:   )
+  ;; WITH-EFFECTS-NEXT:  )
+  ;; WITH-EFFECTS-NEXT:  (i32.const 0)
+  ;; WITH-EFFECTS-NEXT: )
+  (func $caller-non-throwing-in-try (result i32)
+    ;; Inside try_table, a call to a non-throwing function CAN be converted when
+    ;; GlobalEffects is available.
+    (block $catch
+      (return
+        (try_table (result i32) (catch_all $catch)
+          (call $non-throwing-callee)
+        )
+      )
+    )
+    (i32.const 0)
+  )
+
+  ;; NO-EFFECTS:      (func $caller-throwing-arg-in-try (result i32)
+  ;; NO-EFFECTS-NEXT:  (block $catch
+  ;; NO-EFFECTS-NEXT:   (return
+  ;; NO-EFFECTS-NEXT:    (try_table (result i32) (catch_all $catch)
+  ;; NO-EFFECTS-NEXT:     (call $non-throwing-param-callee
+  ;; NO-EFFECTS-NEXT:      (call $throwing-i32-callee)
+  ;; NO-EFFECTS-NEXT:     )
+  ;; NO-EFFECTS-NEXT:    )
+  ;; NO-EFFECTS-NEXT:   )
+  ;; NO-EFFECTS-NEXT:  )
+  ;; NO-EFFECTS-NEXT:  (i32.const 0)
+  ;; NO-EFFECTS-NEXT: )
+  ;; WITH-EFFECTS:      (func $caller-throwing-arg-in-try (result i32)
+  ;; WITH-EFFECTS-NEXT:  (block $catch
+  ;; WITH-EFFECTS-NEXT:   (return
+  ;; WITH-EFFECTS-NEXT:    (try_table (catch_all $catch)
+  ;; WITH-EFFECTS-NEXT:     (return_call $non-throwing-param-callee
+  ;; WITH-EFFECTS-NEXT:      (call $throwing-i32-callee)
+  ;; WITH-EFFECTS-NEXT:     )
+  ;; WITH-EFFECTS-NEXT:    )
+  ;; WITH-EFFECTS-NEXT:   )
+  ;; WITH-EFFECTS-NEXT:  )
+  ;; WITH-EFFECTS-NEXT:  (i32.const 0)
+  ;; WITH-EFFECTS-NEXT: )
+  (func $caller-throwing-arg-in-try (result i32)
+    ;; Even if an argument expression may throw, ShallowEffectAnalyzer only
+    ;; checks whether the call instruction itself can throw, allowing the outer
+    ;; non-throwing call to be converted when GlobalEffects is available.
+    (block $catch
+      (return
+        (try_table (result i32) (catch_all $catch)
+          (call $non-throwing-param-callee
+            (call $throwing-i32-callee)
+          )
+        )
+      )
+    )
+    (i32.const 0)
+  )
+
+  ;; NO-EFFECTS:      (func $caller-outside-try
+  ;; NO-EFFECTS-NEXT:  (return_call $throwing-callee)
+  ;; NO-EFFECTS-NEXT: )
+  ;; WITH-EFFECTS:      (func $caller-outside-try
+  ;; WITH-EFFECTS-NEXT:  (return_call $throwing-callee)
+  ;; WITH-EFFECTS-NEXT: )
+  (func $caller-outside-try
+    ;; Outside any active try/try_table handler, calls in tail position are
+    ;; converted even when EH is enabled on the module.
+    (call $throwing-callee)
+  )
+
+  ;; NO-EFFECTS:      (func $legacy-try-catch
+  ;; NO-EFFECTS-NEXT:  (try
+  ;; NO-EFFECTS-NEXT:   (do
+  ;; NO-EFFECTS-NEXT:    (call $throwing-callee)
+  ;; NO-EFFECTS-NEXT:   )
+  ;; NO-EFFECTS-NEXT:   (catch_all
+  ;; NO-EFFECTS-NEXT:    (return_call $throwing-callee)
+  ;; NO-EFFECTS-NEXT:   )
+  ;; NO-EFFECTS-NEXT:  )
+  ;; NO-EFFECTS-NEXT: )
+  ;; WITH-EFFECTS:      (func $legacy-try-catch
+  ;; WITH-EFFECTS-NEXT:  (try
+  ;; WITH-EFFECTS-NEXT:   (do
+  ;; WITH-EFFECTS-NEXT:    (call $throwing-callee)
+  ;; WITH-EFFECTS-NEXT:   )
+  ;; WITH-EFFECTS-NEXT:   (catch_all
+  ;; WITH-EFFECTS-NEXT:    (return_call $throwing-callee)
+  ;; WITH-EFFECTS-NEXT:   )
+  ;; WITH-EFFECTS-NEXT:  )
+  ;; WITH-EFFECTS-NEXT: )
+  (func $legacy-try-catch
+    ;; Legacy try-catch: try body is protected by catch handler (ehDepth > 0),
+    ;; while catch body is outside the handler (ehDepth == 0).
+    (try
+      (do
+        (call $throwing-callee)
+      )
+      (catch_all
+        (call $throwing-callee)
+      )
+    )
+  )
+
+  ;; NO-EFFECTS:      (func $legacy-try-multiple-catches
+  ;; NO-EFFECTS-NEXT:  (try
+  ;; NO-EFFECTS-NEXT:   (do
+  ;; NO-EFFECTS-NEXT:    (call $throwing-callee)
+  ;; NO-EFFECTS-NEXT:   )
+  ;; NO-EFFECTS-NEXT:   (catch $e1
+  ;; NO-EFFECTS-NEXT:    (return_call $throwing-callee)
+  ;; NO-EFFECTS-NEXT:   )
+  ;; NO-EFFECTS-NEXT:   (catch $e2
+  ;; NO-EFFECTS-NEXT:    (return_call $throwing-callee)
+  ;; NO-EFFECTS-NEXT:   )
+  ;; NO-EFFECTS-NEXT:   (catch_all
+  ;; NO-EFFECTS-NEXT:    (return_call $throwing-callee)
+  ;; NO-EFFECTS-NEXT:   )
+  ;; NO-EFFECTS-NEXT:  )
+  ;; NO-EFFECTS-NEXT: )
+  ;; WITH-EFFECTS:      (func $legacy-try-multiple-catches
+  ;; WITH-EFFECTS-NEXT:  (try
+  ;; WITH-EFFECTS-NEXT:   (do
+  ;; WITH-EFFECTS-NEXT:    (call $throwing-callee)
+  ;; WITH-EFFECTS-NEXT:   )
+  ;; WITH-EFFECTS-NEXT:   (catch $e1
+  ;; WITH-EFFECTS-NEXT:    (return_call $throwing-callee)
+  ;; WITH-EFFECTS-NEXT:   )
+  ;; WITH-EFFECTS-NEXT:   (catch $e2
+  ;; WITH-EFFECTS-NEXT:    (return_call $throwing-callee)
+  ;; WITH-EFFECTS-NEXT:   )
+  ;; WITH-EFFECTS-NEXT:   (catch_all
+  ;; WITH-EFFECTS-NEXT:    (return_call $throwing-callee)
+  ;; WITH-EFFECTS-NEXT:   )
+  ;; WITH-EFFECTS-NEXT:  )
+  ;; WITH-EFFECTS-NEXT: )
+  (func $legacy-try-multiple-catches
+    ;; Legacy try-catch with multiple catch bodies: all catch bodies are outside
+    ;; the try handler (ehDepth == 0) and should convert their tail calls.
+    (try
+      (do
+        (call $throwing-callee)
+      )
+      (catch $e1
+        (call $throwing-callee)
+      )
+      (catch $e2
+        (call $throwing-callee)
+      )
+      (catch_all
+        (call $throwing-callee)
+      )
+    )
+  )
+
+  ;; NO-EFFECTS:      (func $legacy-try-delegate-caller
+  ;; NO-EFFECTS-NEXT:  (try
+  ;; NO-EFFECTS-NEXT:   (do
+  ;; NO-EFFECTS-NEXT:    (return_call $throwing-callee)
+  ;; NO-EFFECTS-NEXT:   )
+  ;; NO-EFFECTS-NEXT:   (delegate 0)
+  ;; NO-EFFECTS-NEXT:  )
+  ;; NO-EFFECTS-NEXT: )
+  ;; WITH-EFFECTS:      (func $legacy-try-delegate-caller
+  ;; WITH-EFFECTS-NEXT:  (try
+  ;; WITH-EFFECTS-NEXT:   (do
+  ;; WITH-EFFECTS-NEXT:    (return_call $throwing-callee)
+  ;; WITH-EFFECTS-NEXT:   )
+  ;; WITH-EFFECTS-NEXT:   (delegate 0)
+  ;; WITH-EFFECTS-NEXT:  )
+  ;; WITH-EFFECTS-NEXT: )
+  (func $legacy-try-delegate-caller
+    ;; A try block that delegates directly to the caller (0) does not catch any
+    ;; exceptions locally, so tail calls inside its body can be converted.
+    (try
+      (do
+        (call $throwing-callee)
+      )
+      (delegate 0)
+    )
+  )
+
+  ;; NO-EFFECTS:      (func $legacy-try-delegate-outer
+  ;; NO-EFFECTS-NEXT:  (try $outer
+  ;; NO-EFFECTS-NEXT:   (do
+  ;; NO-EFFECTS-NEXT:    (try
+  ;; NO-EFFECTS-NEXT:     (do
+  ;; NO-EFFECTS-NEXT:      (call $throwing-callee)
+  ;; NO-EFFECTS-NEXT:     )
+  ;; NO-EFFECTS-NEXT:     (delegate $outer)
+  ;; NO-EFFECTS-NEXT:    )
+  ;; NO-EFFECTS-NEXT:   )
+  ;; NO-EFFECTS-NEXT:   (catch_all
+  ;; NO-EFFECTS-NEXT:    (nop)
+  ;; NO-EFFECTS-NEXT:   )
+  ;; NO-EFFECTS-NEXT:  )
+  ;; NO-EFFECTS-NEXT: )
+  ;; WITH-EFFECTS:      (func $legacy-try-delegate-outer
+  ;; WITH-EFFECTS-NEXT:  (try $outer
+  ;; WITH-EFFECTS-NEXT:   (do
+  ;; WITH-EFFECTS-NEXT:    (try
+  ;; WITH-EFFECTS-NEXT:     (do
+  ;; WITH-EFFECTS-NEXT:      (call $throwing-callee)
+  ;; WITH-EFFECTS-NEXT:     )
+  ;; WITH-EFFECTS-NEXT:     (delegate $outer)
+  ;; WITH-EFFECTS-NEXT:    )
+  ;; WITH-EFFECTS-NEXT:   )
+  ;; WITH-EFFECTS-NEXT:   (catch_all
+  ;; WITH-EFFECTS-NEXT:    (nop)
+  ;; WITH-EFFECTS-NEXT:   )
+  ;; WITH-EFFECTS-NEXT:  )
+  ;; WITH-EFFECTS-NEXT: )
+  (func $legacy-try-delegate-outer
+    ;; A try block that delegates to an outer try with a local catch handler has
+    ;; ehDepth > 0, so throwing tail calls inside its body must not be converted.
+    ;; TODO: Optimize the case where a delegate targets an outer block that has
+    ;; no catch handlers outside of it.
+    (try $outer
+      (do
+        (try
+          (do
+            (call $throwing-callee)
+          )
+          (delegate $outer)
+        )
+      )
+      (catch_all
+        (nop)
+      )
+    )
+  )
+
+  ;; NO-EFFECTS:      (func $nested-try-tables-reset-count (result i32)
+  ;; NO-EFFECTS-NEXT:  (block $catch1
+  ;; NO-EFFECTS-NEXT:   (try_table (catch_all $catch1)
+  ;; NO-EFFECTS-NEXT:    (block $catch2
+  ;; NO-EFFECTS-NEXT:     (try_table (catch_all $catch2)
+  ;; NO-EFFECTS-NEXT:      (return
+  ;; NO-EFFECTS-NEXT:       (call $throwing-i32-callee)
+  ;; NO-EFFECTS-NEXT:      )
+  ;; NO-EFFECTS-NEXT:     )
+  ;; NO-EFFECTS-NEXT:    )
+  ;; NO-EFFECTS-NEXT:    (return
+  ;; NO-EFFECTS-NEXT:     (call $throwing-i32-callee)
+  ;; NO-EFFECTS-NEXT:    )
+  ;; NO-EFFECTS-NEXT:   )
+  ;; NO-EFFECTS-NEXT:  )
+  ;; NO-EFFECTS-NEXT:  (return_call $throwing-i32-callee)
+  ;; NO-EFFECTS-NEXT: )
+  ;; WITH-EFFECTS:      (func $nested-try-tables-reset-count (result i32)
+  ;; WITH-EFFECTS-NEXT:  (block $catch1
+  ;; WITH-EFFECTS-NEXT:   (try_table (catch_all $catch1)
+  ;; WITH-EFFECTS-NEXT:    (block $catch2
+  ;; WITH-EFFECTS-NEXT:     (try_table (catch_all $catch2)
+  ;; WITH-EFFECTS-NEXT:      (return
+  ;; WITH-EFFECTS-NEXT:       (call $throwing-i32-callee)
+  ;; WITH-EFFECTS-NEXT:      )
+  ;; WITH-EFFECTS-NEXT:     )
+  ;; WITH-EFFECTS-NEXT:    )
+  ;; WITH-EFFECTS-NEXT:    (return
+  ;; WITH-EFFECTS-NEXT:     (call $throwing-i32-callee)
+  ;; WITH-EFFECTS-NEXT:    )
+  ;; WITH-EFFECTS-NEXT:   )
+  ;; WITH-EFFECTS-NEXT:  )
+  ;; WITH-EFFECTS-NEXT:  (return_call $throwing-i32-callee)
+  ;; WITH-EFFECTS-NEXT: )
+  (func $nested-try-tables-reset-count (result i32)
+    ;; After exiting nested try_table blocks, ehDepth is decremented back to 0,
+    ;; allowing a subsequent throwing call in tail position to be converted.
+    (block $catch1
+      (try_table (catch_all $catch1)
+        (block $catch2
+          (try_table (catch_all $catch2)
+            (return
+              (call $throwing-i32-callee)
+            )
+          )
+        )
+        (return
+          (call $throwing-i32-callee)
+        )
+      )
+    )
+    (call $throwing-i32-callee)
+  )
+)
diff --git a/test/lit/passes/tail-call-tnh.wast b/test/lit/passes/tail-call-tnh.wast
new file mode 100644
index 00000000000..191970ce075
--- /dev/null
+++ b/test/lit/passes/tail-call-tnh.wast
@@ -0,0 +1,144 @@
+;; NOTE: Assertions have been generated by update_lit_checks.py and should not be edited.
+;; Test tail-call optimization with --traps-never-happen (-tnh).
+
+;; RUN: wasm-opt %s --tail-call --enable-tail-call -S -o - | filecheck %s --check-prefix=DEFAULT
+;; RUN: wasm-opt %s --tail-call -tnh --enable-tail-call -S -o - | filecheck %s --check-prefix=TNH
+
+(module
+  (memory 1 1)
+  ;; DEFAULT:      (global $g (mut i32) (i32.const 0))
+  ;; TNH:      (global $g (mut i32) (i32.const 0))
+  (global $g (mut i32) (i32.const 0))
+
+  ;; DEFAULT:      (func $value-callee (result i32)
+  ;; DEFAULT-NEXT:  (i32.const 1)
+  ;; DEFAULT-NEXT: )
+  ;; TNH:      (func $value-callee (result i32)
+  ;; TNH-NEXT:  (i32.const 1)
+  ;; TNH-NEXT: )
+  (func $value-callee (result i32)
+    (i32.const 1)
+  )
+
+  ;; DEFAULT:      (func $br-if-trapping-condition (param $x i32) (result i32)
+  ;; DEFAULT-NEXT:  (block $out (result i32)
+  ;; DEFAULT-NEXT:   (br_if $out
+  ;; DEFAULT-NEXT:    (call $value-callee)
+  ;; DEFAULT-NEXT:    (i32.load
+  ;; DEFAULT-NEXT:     (local.get $x)
+  ;; DEFAULT-NEXT:    )
+  ;; DEFAULT-NEXT:   )
+  ;; DEFAULT-NEXT:  )
+  ;; DEFAULT-NEXT: )
+  ;; TNH:      (func $br-if-trapping-condition (param $x i32) (result i32)
+  ;; TNH-NEXT:  (block $out
+  ;; TNH-NEXT:   (block
+  ;; TNH-NEXT:    (return_call $value-callee)
+  ;; TNH-NEXT:    (drop
+  ;; TNH-NEXT:     (i32.load
+  ;; TNH-NEXT:      (local.get $x)
+  ;; TNH-NEXT:     )
+  ;; TNH-NEXT:    )
+  ;; TNH-NEXT:   )
+  ;; TNH-NEXT:  )
+  ;; TNH-NEXT: )
+  (func $br-if-trapping-condition (param $x i32) (result i32)
+    ;; Without -tnh, the load in the condition might trap, so converting the
+    ;; call to a return_call (which skips the condition) is disallowed. With
+    ;; -tnh, the load's trap is ignored and the call becomes a return_call.
+    (block $out (result i32)
+      (br_if $out
+        (call $value-callee)
+        (i32.load
+          (local.get $x)
+        )
+      )
+    )
+  )
+
+  ;; DEFAULT:      (func $br-table-trapping-condition (param $x i32) (result i32)
+  ;; DEFAULT-NEXT:  (block $out1 (result i32)
+  ;; DEFAULT-NEXT:   (block $out2 (result i32)
+  ;; DEFAULT-NEXT:    (br_table $out1 $out2
+  ;; DEFAULT-NEXT:     (call $value-callee)
+  ;; DEFAULT-NEXT:     (i32.div_s
+  ;; DEFAULT-NEXT:      (i32.const 10)
+  ;; DEFAULT-NEXT:      (local.get $x)
+  ;; DEFAULT-NEXT:     )
+  ;; DEFAULT-NEXT:    )
+  ;; DEFAULT-NEXT:   )
+  ;; DEFAULT-NEXT:  )
+  ;; DEFAULT-NEXT: )
+  ;; TNH:      (func $br-table-trapping-condition (param $x i32) (result i32)
+  ;; TNH-NEXT:  (block $out1
+  ;; TNH-NEXT:   (block $out2
+  ;; TNH-NEXT:    (block
+  ;; TNH-NEXT:     (return_call $value-callee)
+  ;; TNH-NEXT:     (drop
+  ;; TNH-NEXT:      (i32.div_s
+  ;; TNH-NEXT:       (i32.const 10)
+  ;; TNH-NEXT:       (local.get $x)
+  ;; TNH-NEXT:      )
+  ;; TNH-NEXT:     )
+  ;; TNH-NEXT:    )
+  ;; TNH-NEXT:   )
+  ;; TNH-NEXT:  )
+  ;; TNH-NEXT: )
+  (func $br-table-trapping-condition (param $x i32) (result i32)
+    ;; Similarly, a potentially trapping division in a br_table condition
+    ;; prevents tail-call conversion unless -tnh is enabled.
+    (block $out1 (result i32)
+      (block $out2 (result i32)
+        (br_table $out1 $out2
+          (call $value-callee)
+          (i32.div_s
+            (i32.const 10)
+            (local.get $x)
+          )
+        )
+      )
+    )
+  )
+
+  ;; DEFAULT:      (func $br-if-non-trap-side-effect (result i32)
+  ;; DEFAULT-NEXT:  (block $out (result i32)
+  ;; DEFAULT-NEXT:   (br_if $out
+  ;; DEFAULT-NEXT:    (call $value-callee)
+  ;; DEFAULT-NEXT:    (block (result i32)
+  ;; DEFAULT-NEXT:     (global.set $g
+  ;; DEFAULT-NEXT:      (i32.const 1)
+  ;; DEFAULT-NEXT:     )
+  ;; DEFAULT-NEXT:     (i32.const 0)
+  ;; DEFAULT-NEXT:    )
+  ;; DEFAULT-NEXT:   )
+  ;; DEFAULT-NEXT:  )
+  ;; DEFAULT-NEXT: )
+  ;; TNH:      (func $br-if-non-trap-side-effect (result i32)
+  ;; TNH-NEXT:  (block $out (result i32)
+  ;; TNH-NEXT:   (br_if $out
+  ;; TNH-NEXT:    (call $value-callee)
+  ;; TNH-NEXT:    (block (result i32)
+  ;; TNH-NEXT:     (global.set $g
+  ;; TNH-NEXT:      (i32.const 1)
+  ;; TNH-NEXT:     )
+  ;; TNH-NEXT:     (i32.const 0)
+  ;; TNH-NEXT:    )
+  ;; TNH-NEXT:   )
+  ;; TNH-NEXT:  )
+  ;; TNH-NEXT: )
+  (func $br-if-non-trap-side-effect (result i32)
+    ;; Non-trap side effects (like global.set) in a condition still inhibit
+    ;; optimization even when -tnh is enabled.
+    (block $out (result i32)
+      (br_if $out
+        (call $value-callee)
+        (block (result i32)
+          (global.set $g
+            (i32.const 1)
+          )
+          (i32.const 0)
+        )
+      )
+    )
+  )
+)
diff --git a/test/lit/passes/tail-call.wast b/test/lit/passes/tail-call.wast
new file mode 100644
index 00000000000..c0c8bc56df0
--- /dev/null
+++ b/test/lit/passes/tail-call.wast
@@ -0,0 +1,675 @@
+;; NOTE: Assertions have been generated by update_lit_checks.py and should not be edited.
+;; Test converting calls in tail position to return calls.
+
+;; RUN: wasm-opt %s --tail-call --enable-tail-call --enable-gc --enable-reference-types --enable-multivalue -S -o - | filecheck %s
+
+(module
+  ;; CHECK:      (type $none-to-i32 (func (result i32)))
+
+  ;; CHECK:      (type $i32-to-none (func (param i32)))
+
+  ;; CHECK:      (type $none-to-none (func))
+  (type $none-to-none (func))
+  (type $none-to-i32 (func (result i32)))
+  (type $i32-to-none (func (param i32)))
+  ;; CHECK:      (type $struct (sub (struct)))
+  (type $struct (sub (struct)))
+  ;; CHECK:      (import "binaryen-intrinsics" "call.without.effects" (func $cwe (type $6) (param i32 funcref) (result i32)))
+  (import "binaryen-intrinsics" "call.without.effects" (func $cwe (param i32) (param funcref) (result i32)))
+  ;; CHECK:      (global $g (mut i32) (i32.const 0))
+  (global $g (mut i32) (i32.const 0))
+  ;; CHECK:      (table $table 1 funcref)
+  (table $table 1 funcref)
+
+  ;; CHECK:      (func $void-callee (type $none-to-none)
+  ;; CHECK-NEXT: )
+  (func $void-callee)
+  ;; CHECK:      (func $void-arg-callee (type $i32-to-none) (param $x i32)
+  ;; CHECK-NEXT: )
+  (func $void-arg-callee (param $x i32))
+  ;; CHECK:      (func $i32-to-i32-callee (type $2) (param $x i32) (result i32)
+  ;; CHECK-NEXT:  (local.get $x)
+  ;; CHECK-NEXT: )
+  (func $i32-to-i32-callee (param $x i32) (result i32)
+    (local.get $x)
+  )
+  ;; CHECK:      (func $value-callee (type $none-to-i32) (result i32)
+  ;; CHECK-NEXT:  (i32.const 1)
+  ;; CHECK-NEXT: )
+  (func $value-callee (result i32)
+    (i32.const 1)
+  )
+  ;; CHECK:      (func $ref-callee (type $none-to-i32) (result i32)
+  ;; CHECK-NEXT:  (i32.const 2)
+  ;; CHECK-NEXT: )
+  (func $ref-callee (result i32)
+    (i32.const 2)
+  )
+  ;; CHECK:      (func $param-callee (type $7) (param $x i32) (param $y i32) (result i32)
+  ;; CHECK-NEXT:  (i32.add
+  ;; CHECK-NEXT:   (local.get $x)
+  ;; CHECK-NEXT:   (local.get $y)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $param-callee (param $x i32) (param $y i32) (result i32)
+    (i32.add
+      (local.get $x)
+      (local.get $y)
+    )
+  )
+  ;; CHECK:      (func $subtype-callee (type $8) (result (ref $struct))
+  ;; CHECK-NEXT:  (struct.new_default $struct)
+  ;; CHECK-NEXT: )
+  (func $subtype-callee (result (ref $struct))
+    (struct.new_default $struct)
+  )
+  ;; CHECK:      (func $multivalue-callee (type $5) (result i32 i64)
+  ;; CHECK-NEXT:  (tuple.make 2
+  ;; CHECK-NEXT:   (i32.const 1)
+  ;; CHECK-NEXT:   (i64.const 2)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $multivalue-callee (result i32 i64)
+    (tuple.make 2
+      (i32.const 1)
+      (i64.const 2)
+    )
+  )
+  (elem (i32.const 0) $value-callee)
+
+  ;; CHECK:      (func $direct-void (type $none-to-none)
+  ;; CHECK-NEXT:  (return_call $void-callee)
+  ;; CHECK-NEXT: )
+  (func $direct-void
+    ;; A direct void call at the end of a function becomes a return_call.
+    (call $void-callee)
+  )
+
+  ;; CHECK:      (func $direct-void-ret (type $none-to-none)
+  ;; CHECK-NEXT:  (return_call $void-callee)
+  ;; CHECK-NEXT:  (return)
+  ;; CHECK-NEXT: )
+  (func $direct-void-ret
+    ;; A void call immediately preceding a return becomes a return_call.
+    (call $void-callee)
+    (return)
+  )
+
+  ;; CHECK:      (func $direct-value (type $none-to-i32) (result i32)
+  ;; CHECK-NEXT:  (return
+  ;; CHECK-NEXT:   (return_call $value-callee)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $direct-value (result i32)
+    ;; A return wrapping a call becomes a return_call.
+    (return
+      (call $value-callee)
+    )
+  )
+
+  ;; CHECK:      (func $call-with-params (type $2) (param $x i32) (result i32)
+  ;; CHECK-NEXT:  (return
+  ;; CHECK-NEXT:   (return_call $param-callee
+  ;; CHECK-NEXT:    (local.get $x)
+  ;; CHECK-NEXT:    (block (result i32)
+  ;; CHECK-NEXT:     (global.set $g
+  ;; CHECK-NEXT:      (i32.const 1)
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:     (call $value-callee)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $call-with-params (param $x i32) (result i32)
+    ;; Calls with parameters, including side-effecting parameter expressions,
+    ;; are still converted to return_call because operands are evaluated before
+    ;; the call transfers control.
+    (return
+      (call $param-callee
+        (local.get $x)
+        (block (result i32)
+          (global.set $g
+            (i32.const 1)
+          )
+          (call $value-callee)
+        )
+      )
+    )
+  )
+
+  ;; CHECK:      (func $subtype-return (type $9) (result anyref)
+  ;; CHECK-NEXT:  (return_call $subtype-callee)
+  ;; CHECK-NEXT: )
+  (func $subtype-return (result anyref)
+    ;; A call returning a subtype of the enclosing function's result type can be
+    ;; converted to return_call.
+    (call $subtype-callee)
+  )
+
+  ;; CHECK:      (func $multivalue (type $5) (result i32 i64)
+  ;; CHECK-NEXT:  (return_call $multivalue-callee)
+  ;; CHECK-NEXT: )
+  (func $multivalue (result i32 i64)
+    ;; Multivalue return calls are supported.
+    (call $multivalue-callee)
+  )
+
+  ;; CHECK:      (func $conditional (type $2) (param $condition i32) (result i32)
+  ;; CHECK-NEXT:  (if
+  ;; CHECK-NEXT:   (local.get $condition)
+  ;; CHECK-NEXT:   (then
+  ;; CHECK-NEXT:    (return_call $value-callee)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (else
+  ;; CHECK-NEXT:    (return_call $ref-callee)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $conditional (param $condition i32) (result i32)
+    ;; Both arms of an if in tail position are converted to return_call.
+    (if (result i32)
+      (local.get $condition)
+      (then
+        (call $value-callee)
+      )
+      (else
+        (call $ref-callee)
+      )
+    )
+  )
+
+  ;; CHECK:      (func $one-armed-if (type $i32-to-none) (param $condition i32)
+  ;; CHECK-NEXT:  (if
+  ;; CHECK-NEXT:   (local.get $condition)
+  ;; CHECK-NEXT:   (then
+  ;; CHECK-NEXT:    (return_call $void-callee)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $one-armed-if (param $condition i32)
+    ;; In a void function, the arm of a one-armed if in tail position is
+    ;; converted to return_call.
+    (if
+      (local.get $condition)
+      (then
+        (call $void-callee)
+      )
+    )
+  )
+
+  ;; CHECK:      (func $indirect (type $none-to-i32) (result i32)
+  ;; CHECK-NEXT:  (return_call_indirect $table (type $none-to-i32)
+  ;; CHECK-NEXT:   (i32.const 0)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $indirect (result i32)
+    ;; An indirect call in tail position becomes a return_call_indirect.
+    (call_indirect $table (type $none-to-i32)
+      (i32.const 0)
+    )
+  )
+
+  ;; CHECK:      (func $ref (type $none-to-i32) (result i32)
+  ;; CHECK-NEXT:  (return_call_ref $none-to-i32
+  ;; CHECK-NEXT:   (ref.func $value-callee)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $ref (result i32)
+    ;; A call_ref in tail position becomes a return_call_ref.
+    (call_ref $none-to-i32
+      (ref.func $value-callee)
+    )
+  )
+
+  ;; CHECK:      (func $break (type $2) (param $condition i32) (result i32)
+  ;; CHECK-NEXT:  (block $out
+  ;; CHECK-NEXT:   (if
+  ;; CHECK-NEXT:    (local.get $condition)
+  ;; CHECK-NEXT:    (then
+  ;; CHECK-NEXT:     (return_call $value-callee)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (return_call $ref-callee)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $break (param $condition i32) (result i32)
+    ;; An unconditional branch to a tail block and the fallthrough of that block
+    ;; are both in tail position.
+    (block $out (result i32)
+      (if
+        (local.get $condition)
+        (then
+          (br $out
+            (call $value-callee)
+          )
+        )
+      )
+      (call $ref-callee)
+    )
+  )
+
+  ;; CHECK:      (func $return-break (type $2) (param $condition i32) (result i32)
+  ;; CHECK-NEXT:  (return
+  ;; CHECK-NEXT:   (block $out
+  ;; CHECK-NEXT:    (if
+  ;; CHECK-NEXT:     (local.get $condition)
+  ;; CHECK-NEXT:     (then
+  ;; CHECK-NEXT:      (return_call $value-callee)
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:    (return_call $ref-callee)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $return-break (param $condition i32) (result i32)
+    ;; A block wrapped in an explicit return is in tail position, so branches to
+    ;; it are also in tail position.
+    (return
+      (block $out (result i32)
+        (if
+          (local.get $condition)
+          (then
+            (br $out
+              (call $value-callee)
+            )
+          )
+        )
+        (call $ref-callee)
+      )
+    )
+  )
+
+  ;; CHECK:      (func $br-if-tail (type $2) (param $condition i32) (result i32)
+  ;; CHECK-NEXT:  (block $out
+  ;; CHECK-NEXT:   (block
+  ;; CHECK-NEXT:    (return_call $value-callee)
+  ;; CHECK-NEXT:    (drop
+  ;; CHECK-NEXT:     (local.get $condition)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $br-if-tail (param $condition i32) (result i32)
+    ;; A conditional branch in tail position to a tail block is converted
+    ;; because both taking the branch and falling through exit the function with
+    ;; the call's result.
+    (block $out (result i32)
+      (br_if $out
+        (call $value-callee)
+        (local.get $condition)
+      )
+    )
+  )
+
+  ;; CHECK:      (func $br-if-not-tail (type $2) (param $condition i32) (result i32)
+  ;; CHECK-NEXT:  (block $out (result i32)
+  ;; CHECK-NEXT:   (drop
+  ;; CHECK-NEXT:    (br_if $out
+  ;; CHECK-NEXT:     (call $value-callee)
+  ;; CHECK-NEXT:     (local.get $condition)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (i32.const 42)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $br-if-not-tail (param $condition i32) (result i32)
+    ;; A conditional branch NOT in tail position must not be converted.
+    (block $out (result i32)
+      (drop
+        (br_if $out
+          (call $value-callee)
+          (local.get $condition)
+        )
+      )
+      (i32.const 42)
+    )
+  )
+
+  ;; CHECK:      (func $br-if-side-effect (type $none-to-i32) (result i32)
+  ;; CHECK-NEXT:  (block $out (result i32)
+  ;; CHECK-NEXT:   (br_if $out
+  ;; CHECK-NEXT:    (call $value-callee)
+  ;; CHECK-NEXT:    (block (result i32)
+  ;; CHECK-NEXT:     (global.set $g
+  ;; CHECK-NEXT:      (i32.const 1)
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:     (i32.const 0)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $br-if-side-effect (result i32)
+    ;; A conditional branch in tail position whose condition has side effects
+    ;; must not be converted because converting would skip the side effect.
+    (block $out (result i32)
+      (br_if $out
+        (call $value-callee)
+        (block (result i32)
+          (global.set $g
+            (i32.const 1)
+          )
+          (i32.const 0)
+        )
+      )
+    )
+  )
+
+  ;; CHECK:      (func $br-table-all-tail (type $2) (param $idx i32) (result i32)
+  ;; CHECK-NEXT:  (block $out1
+  ;; CHECK-NEXT:   (block $out2
+  ;; CHECK-NEXT:    (block
+  ;; CHECK-NEXT:     (return_call $value-callee)
+  ;; CHECK-NEXT:     (drop
+  ;; CHECK-NEXT:      (local.get $idx)
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $br-table-all-tail (param $idx i32) (result i32)
+    ;; A br_table where all targets exit the function can be converted.
+    (block $out1 (result i32)
+      (block $out2 (result i32)
+        (br_table $out1 $out2
+          (call $value-callee)
+          (local.get $idx)
+        )
+      )
+    )
+  )
+
+  ;; CHECK:      (func $br-table-not-all-tail (type $2) (param $idx i32) (result i32)
+  ;; CHECK-NEXT:  (block $exit (result i32)
+  ;; CHECK-NEXT:   (drop
+  ;; CHECK-NEXT:    (block $not-exit (result i32)
+  ;; CHECK-NEXT:     (br_table $not-exit $exit
+  ;; CHECK-NEXT:      (call $value-callee)
+  ;; CHECK-NEXT:      (local.get $idx)
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (i32.const 42)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $br-table-not-all-tail (param $idx i32) (result i32)
+    ;; A br_table where not all targets exit the function must not be converted.
+    (block $exit (result i32)
+      (drop
+        (block $not-exit (result i32)
+          (br_table $not-exit $exit
+            (call $value-callee)
+            (local.get $idx)
+          )
+        )
+      )
+      (i32.const 42)
+    )
+  )
+
+  ;; CHECK:      (func $void-break (type $i32-to-none) (param $condition i32)
+  ;; CHECK-NEXT:  (block $out
+  ;; CHECK-NEXT:   (if
+  ;; CHECK-NEXT:    (local.get $condition)
+  ;; CHECK-NEXT:    (then
+  ;; CHECK-NEXT:     (return_call $void-callee)
+  ;; CHECK-NEXT:     (br $out)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (return_call $void-callee)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $void-break (param $condition i32)
+    ;; In a void function, statements immediately preceding an unconditional
+    ;; branch to a tail block or falling through a tail block are converted.
+    (block $out
+      (if
+        (local.get $condition)
+        (then
+          (call $void-callee)
+          (br $out)
+        )
+      )
+      (call $void-callee)
+    )
+  )
+
+  ;; CHECK:      (func $void-br-if-tail (type $i32-to-none) (param $condition i32)
+  ;; CHECK-NEXT:  (block $out
+  ;; CHECK-NEXT:   (return_call $void-callee)
+  ;; CHECK-NEXT:   (br_if $out
+  ;; CHECK-NEXT:    (local.get $condition)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $void-br-if-tail (param $condition i32)
+    ;; In a void function, a call preceding a conditional branch in tail
+    ;; position targeting a tail block is converted.
+    (block $out
+      (call $void-callee)
+      (br_if $out
+        (local.get $condition)
+      )
+    )
+  )
+
+  ;; CHECK:      (func $void-br-if-not-tail (type $i32-to-none) (param $condition i32)
+  ;; CHECK-NEXT:  (block $out
+  ;; CHECK-NEXT:   (call $void-callee)
+  ;; CHECK-NEXT:   (br_if $out
+  ;; CHECK-NEXT:    (local.get $condition)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (nop)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $void-br-if-not-tail (param $condition i32)
+    ;; In a void function, a call preceding a conditional branch that is not in
+    ;; tail position must not be converted.
+    (block $out
+      (call $void-callee)
+      (br_if $out
+        (local.get $condition)
+      )
+      (nop)
+    )
+  )
+
+  ;; CHECK:      (func $void-br-table-all-tail (type $i32-to-none) (param $idx i32)
+  ;; CHECK-NEXT:  (block $out1
+  ;; CHECK-NEXT:   (block $out2
+  ;; CHECK-NEXT:    (return_call $void-callee)
+  ;; CHECK-NEXT:    (br_table $out1 $out2
+  ;; CHECK-NEXT:     (local.get $idx)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $void-br-table-all-tail (param $idx i32)
+    ;; In a void function, a call preceding a br_table whose targets are all tail
+    ;; blocks is converted.
+    (block $out1
+      (block $out2
+        (call $void-callee)
+        (br_table $out1 $out2
+          (local.get $idx)
+        )
+      )
+    )
+  )
+
+  ;; CHECK:      (func $void-br-table-not-all-tail (type $i32-to-none) (param $idx i32)
+  ;; CHECK-NEXT:  (block $exit
+  ;; CHECK-NEXT:   (block $not-exit
+  ;; CHECK-NEXT:    (call $void-callee)
+  ;; CHECK-NEXT:    (br_table $not-exit $exit
+  ;; CHECK-NEXT:     (local.get $idx)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (nop)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $void-br-table-not-all-tail (param $idx i32)
+    ;; In a void function, a call preceding a br_table where not all targets are
+    ;; tail blocks must not be converted.
+    (block $exit
+      (block $not-exit
+        (call $void-callee)
+        (br_table $not-exit $exit
+          (local.get $idx)
+        )
+      )
+      (nop)
+    )
+  )
+
+  ;; CHECK:      (func $loop-tail (type $2) (param $condition i32) (result i32)
+  ;; CHECK-NEXT:  (loop $l
+  ;; CHECK-NEXT:   (br_if $l
+  ;; CHECK-NEXT:    (local.get $condition)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (return_call $value-callee)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $loop-tail (param $condition i32) (result i32)
+    ;; A loop whose fallthrough is in tail position converts its fallthrough call
+    ;; to a return_call.
+    (loop $l (result i32)
+      (br_if $l
+        (local.get $condition)
+      )
+      (call $value-callee)
+    )
+  )
+
+  ;; CHECK:      (func $loop-backedge-not-tail (type $none-to-none)
+  ;; CHECK-NEXT:  (loop $l
+  ;; CHECK-NEXT:   (call $void-callee)
+  ;; CHECK-NEXT:   (br $l)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $loop-backedge-not-tail
+    ;; A branch to a loop header is a backedge rather than an exit, so a call
+    ;; preceding a loop branch must not be converted.
+    (loop $l
+      (call $void-callee)
+      (br $l)
+    )
+  )
+
+  ;; CHECK:      (func $not-tail (type $none-to-none)
+  ;; CHECK-NEXT:  (call $void-callee)
+  ;; CHECK-NEXT:  (nop)
+  ;; CHECK-NEXT: )
+  (func $not-tail
+    ;; A call followed by another instruction is not in tail position.
+    (call $void-callee)
+    (nop)
+  )
+
+  ;; CHECK:      (func $mismatched-result (type $none-to-none)
+  ;; CHECK-NEXT:  (drop
+  ;; CHECK-NEXT:   (call $value-callee)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $mismatched-result
+    ;; A dropped call is not in tail position.
+    (drop
+      (call $value-callee)
+    )
+  )
+
+  ;; CHECK:      (func $dead-after-return (type $none-to-i32) (result i32)
+  ;; CHECK-NEXT:  (return
+  ;; CHECK-NEXT:   (i32.const 1)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT:  (call $void-callee)
+  ;; CHECK-NEXT: )
+  (func $dead-after-return (result i32)
+    ;; A dead void call at the end of a block after an unreachable instruction
+    ;; has a mismatched return type and is safely ignored.
+    (block
+      (return
+        (i32.const 1)
+      )
+      (call $void-callee)
+    )
+  )
+
+  ;; CHECK:      (func $unreachable-arg-mismatched-call (type $none-to-i32) (result i32)
+  ;; CHECK-NEXT:  (call $void-arg-callee
+  ;; CHECK-NEXT:   (unreachable)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $unreachable-arg-mismatched-call (result i32)
+    ;; Unreachable calls (e.g. due to an unreachable operand) are not converted
+    ;; to return calls, avoiding return type mismatches and optimizing dead code.
+    (call $void-arg-callee
+      (unreachable)
+    )
+  )
+
+  ;; CHECK:      (func $unreachable-arg-matching-call (type $none-to-i32) (result i32)
+  ;; CHECK-NEXT:  (call $param-callee
+  ;; CHECK-NEXT:   (unreachable)
+  ;; CHECK-NEXT:   (i32.const 1)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $unreachable-arg-matching-call (result i32)
+    (call $param-callee
+      (unreachable)
+      (i32.const 1)
+    )
+  )
+
+  ;; CHECK:      (func $unreachable-arg-mismatched-call-indirect (type $none-to-i32) (result i32)
+  ;; CHECK-NEXT:  (call_indirect $table (type $i32-to-none)
+  ;; CHECK-NEXT:   (unreachable)
+  ;; CHECK-NEXT:   (i32.const 0)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $unreachable-arg-mismatched-call-indirect (result i32)
+    (call_indirect $table (type $i32-to-none)
+      (unreachable)
+      (i32.const 0)
+    )
+  )
+
+  ;; CHECK:      (func $unreachable-arg-mismatched-call-ref (type $10) (param $f (ref $i32-to-none)) (result i32)
+  ;; CHECK-NEXT:  (call_ref $i32-to-none
+  ;; CHECK-NEXT:   (unreachable)
+  ;; CHECK-NEXT:   (local.get $f)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $unreachable-arg-mismatched-call-ref (param $f (ref $i32-to-none)) (result i32)
+    (call_ref $i32-to-none
+      (unreachable)
+      (local.get $f)
+    )
+  )
+
+  ;; CHECK:      (func $unreachable-arg-mismatched-cwe (type $none-to-i32) (result i32)
+  ;; CHECK-NEXT:  (call $cwe
+  ;; CHECK-NEXT:   (unreachable)
+  ;; CHECK-NEXT:   (ref.func $void-arg-callee)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $unreachable-arg-mismatched-cwe (result i32)
+    (call $cwe
+      (unreachable)
+      (ref.func $void-arg-callee)
+    )
+  )
+
+  ;; CHECK:      (func $tail-cwe (type $none-to-i32) (result i32)
+  ;; CHECK-NEXT:  (return_call $cwe
+  ;; CHECK-NEXT:   (i32.const 42)
+  ;; CHECK-NEXT:   (ref.func $i32-to-i32-callee)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $tail-cwe (result i32)
+    ;; call.without.effects is optimized when reachable.
+    (call $cwe
+      (i32.const 42)
+      (ref.func $i32-to-i32-callee)
+    )
+  )
+)
diff --git a/test/lit/passes/toolchain-inlining.wast b/test/lit/passes/toolchain-inlining.wast
index cc6cfb9364f..3cf46ea34b0 100644
--- a/test/lit/passes/toolchain-inlining.wast
+++ b/test/lit/passes/toolchain-inlining.wast
@@ -17,7 +17,7 @@
   )
 
   (func $never-unannotated (result i32)
-    ;; Idential to above, but without the annotation. This will be inlined,
+    ;; Identical to above, but without the annotation. This will be inlined,
     ;; showing the hint works.
     (i32.const 42)
   )
@@ -61,7 +61,7 @@
   ;; CHECK-NEXT: )
   (func $always-unannotated (result i32)
     (local $x i32)
-    ;; Idential to above, but without the annotation. This will not be inlined,
+    ;; Identical to above, but without the annotation. This will not be inlined,
     ;; showing the hint works.
     (loop $loop
       (local.set $x
diff --git a/test/lit/passes/type-generalizing.wast b/test/lit/passes/type-generalizing.wast
index 66e3520056d..c9a1c2f9326 100644
--- a/test/lit/passes/type-generalizing.wast
+++ b/test/lit/passes/type-generalizing.wast
@@ -317,7 +317,7 @@
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $local-get-set-join (param $dest1 anyref) (param $dest2 eqref)
-  ;; This wll be optimized to eqref.
+  ;; This will be optimized to eqref.
   (local $var i31ref)
   ;; Require that typeof($var) <: typeof($dest1).
   (local.set $dest1
diff --git a/test/lit/passes/type-merging.wast b/test/lit/passes/type-merging.wast
index 5a5d6a2c004..c12c90d8c0c 100644
--- a/test/lit/passes/type-merging.wast
+++ b/test/lit/passes/type-merging.wast
@@ -795,7 +795,7 @@
   )
 )
 
-;; Regresssion test for a bug in which we merged A into A', but
+;; Regression test for a bug in which we merged A into A', but
 ;; type-updating.cpp ordered B before A', so the supertype ordering was
 ;; incorrect.
 (module
diff --git a/test/lit/passes/type-refining-gufa-rmw.wast b/test/lit/passes/type-refining-gufa-rmw.wast
index 24aec709a98..760dd5cd75f 100644
--- a/test/lit/passes/type-refining-gufa-rmw.wast
+++ b/test/lit/passes/type-refining-gufa-rmw.wast
@@ -415,3 +415,62 @@
   )
  )
 )
+
+(module
+ ;; NRML:      (type $struct (sub (struct (field (mut (ref null $struct))))))
+ ;; GUFA:      (rec
+ ;; GUFA-NEXT:  (type $struct (sub (struct (field (mut nullref)))))
+ (type $struct (sub (struct (field (mut (ref null $struct))))))
+
+ ;; NRML:      (type $1 (func (param (ref null $struct))))
+
+ ;; NRML:      (func $test (type $1) (param $struct (ref null $struct))
+ ;; NRML-NEXT:  (drop
+ ;; NRML-NEXT:   (struct.new_default $struct)
+ ;; NRML-NEXT:  )
+ ;; NRML-NEXT:  (drop
+ ;; NRML-NEXT:   (struct.atomic.rmw.cmpxchg acqrel acqrel $struct 0
+ ;; NRML-NEXT:    (local.get $struct)
+ ;; NRML-NEXT:    (unreachable)
+ ;; NRML-NEXT:    (local.get $struct)
+ ;; NRML-NEXT:   )
+ ;; NRML-NEXT:  )
+ ;; NRML-NEXT: )
+ ;; GUFA:       (type $1 (func (param (ref null $struct))))
+
+ ;; GUFA:      (func $test (type $1) (param $struct (ref null $struct))
+ ;; GUFA-NEXT:  (drop
+ ;; GUFA-NEXT:   (struct.new_default $struct)
+ ;; GUFA-NEXT:  )
+ ;; GUFA-NEXT:  (drop
+ ;; GUFA-NEXT:   (struct.atomic.rmw.cmpxchg acqrel acqrel $struct 0
+ ;; GUFA-NEXT:    (local.get $struct)
+ ;; GUFA-NEXT:    (unreachable)
+ ;; GUFA-NEXT:    (block (result nullref)
+ ;; GUFA-NEXT:     (drop
+ ;; GUFA-NEXT:      (local.get $struct)
+ ;; GUFA-NEXT:     )
+ ;; GUFA-NEXT:     (ref.null none)
+ ;; GUFA-NEXT:    )
+ ;; GUFA-NEXT:   )
+ ;; GUFA-NEXT:  )
+ ;; GUFA-NEXT: )
+ (func $test (param $struct (ref null $struct))
+  ;; Use the type, writing only nulls.
+  (drop
+   (struct.new_default $struct)
+  )
+  ;; An unreachable cmpxchg, but where the ref and value are not unreachable.
+  ;; The value must still validate as if it were written, so we will fix it up
+  ;; with a null, as the field is refined to a null (in GUFA mode, which
+  ;; does that refining).
+  (drop
+   (struct.atomic.rmw.cmpxchg acqrel acqrel $struct 0
+    (local.get $struct)
+    (unreachable)
+    (local.get $struct)
+   )
+  )
+ )
+)
+
diff --git a/test/lit/passes/type-ssa-desc.wast b/test/lit/passes/type-ssa-desc.wast
index f015501c689..852bfdf6d39 100644
--- a/test/lit/passes/type-ssa-desc.wast
+++ b/test/lit/passes/type-ssa-desc.wast
@@ -7,8 +7,8 @@
     ;; CHECK:      (rec
     ;; CHECK-NEXT:  (type $struct (descriptor $desc) (struct))
     (type $struct (descriptor $desc) (struct))
-    ;; CHECK:       (type $desc (sub (describes $struct) (struct (field i32))))
-    (type $desc (sub (describes $struct) (struct (field i32))))
+    ;; CHECK:       (type $desc (describes $struct) (struct (field i32)))
+    (type $desc (describes $struct) (struct (field i32)))
   )
   ;; CHECK:      (type $2 (func (result (ref $desc))))
 
@@ -27,10 +27,10 @@
 (module
   (rec
     ;; CHECK:      (rec
-    ;; CHECK-NEXT:  (type $struct (sub (descriptor $desc) (struct (field i32))))
-    (type $struct (sub (descriptor $desc) (struct (field i32))))
+    ;; CHECK-NEXT:  (type $struct (descriptor $desc) (struct (field i32)))
+    (type $struct (descriptor $desc) (struct (field i32)))
     ;; CHECK:       (type $desc (describes $struct) (struct))
-    (type $desc (sub final (describes $struct) (struct)))
+    (type $desc (describes $struct) (struct))
   )
 
   ;; CHECK:      (type $2 (func (result (ref $struct))))
@@ -43,7 +43,7 @@
   (func $final-desc (result (ref $struct))
     ;; We could optimize the allocation of the struct, but we would need to
     ;; update the descriptor to be a corresponding new subtype. The descriptor
-    ;; is final, so this is not posssible and we cannot optimize.
+    ;; is final, so this is not possible and we cannot optimize.
     (struct.new_default_desc $struct
       (struct.new $desc)
     )
diff --git a/test/lit/passes/unsubtyping-jsinterop.wast b/test/lit/passes/unsubtyping-jsinterop.wast
index 2adf8e91bc4..0b6acab0273 100644
--- a/test/lit/passes/unsubtyping-jsinterop.wast
+++ b/test/lit/passes/unsubtyping-jsinterop.wast
@@ -31,7 +31,7 @@
     ;; CHECK:       (type $sub-param (sub $super-param (struct)))
     (type $sub-param (sub $super-param (struct)))
 
-    ;; Returning a type to JS means it flows into an anyref posistion, which
+    ;; Returning a type to JS means it flows into an anyref position, which
     ;; can cause the subytpe relationship to be kept.
     ;; CHECK:       (type $super-result (sub (struct)))
     (type $super-result (sub (struct)))
diff --git a/test/lit/passes/unsubtyping-stack-switching.wast b/test/lit/passes/unsubtyping-stack-switching.wast
index 6ed6039ca24..8d0531e4eab 100644
--- a/test/lit/passes/unsubtyping-stack-switching.wast
+++ b/test/lit/passes/unsubtyping-stack-switching.wast
@@ -972,7 +972,7 @@
     (local $cont (ref null $cont))
     (tuple.drop 2
       (block $l (result (ref null $super) (ref null $cont))
-        ;; Now with a resume_throw_ref. This requies $sub <: $super.
+        ;; Now with a resume_throw_ref. This requires $sub <: $super.
         (resume_throw_ref $cont (on $send-sub $l)
           (local.get $exn)
           (local.get $cont)
diff --git a/test/lit/publish.wast b/test/lit/publish.wast
new file mode 100644
index 00000000000..c7b3cecd30e
--- /dev/null
+++ b/test/lit/publish.wast
@@ -0,0 +1,206 @@
+;; NOTE: Assertions have been generated by update_lit_checks.py and should not be edited.
+;; RUN: wasm-opt %s -all -S -o - | filecheck %s
+;; RUN: wasm-opt %s -all --roundtrip -S -o - | filecheck %s --check-prefix=RTRIP
+
+(module
+  ;; CHECK:      (type $struct (struct (field i32)))
+  ;; RTRIP:      (type $struct (struct (field i32)))
+  (type $struct (struct (field i32)))
+  ;; CHECK:      (type $shared-struct (shared (struct (field (mut i32)))))
+  ;; RTRIP:      (type $shared-struct (shared (struct (field (mut i32)))))
+  (type $shared-struct (shared (struct (field (mut i32)))))
+  ;; CHECK:      (type $array (array (mut i8)))
+  ;; RTRIP:      (type $array (array (mut i8)))
+  (type $array (array (mut i8)))
+  ;; CHECK:      (type $shared-array (shared (array (mut i8))))
+  ;; RTRIP:      (type $shared-array (shared (array (mut i8))))
+  (type $shared-array (shared (array (mut i8))))
+
+  ;; CHECK:      (func $publish-struct (type $4) (param $x (ref $struct)) (result (ref $struct))
+  ;; CHECK-NEXT:  (publish
+  ;; CHECK-NEXT:   (local.get $x)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  ;; RTRIP:      (func $publish-struct (type $4) (param $x (ref $struct)) (result (ref $struct))
+  ;; RTRIP-NEXT:  (publish
+  ;; RTRIP-NEXT:   (local.get $x)
+  ;; RTRIP-NEXT:  )
+  ;; RTRIP-NEXT: )
+  (func $publish-struct (param $x (ref $struct)) (result (ref $struct))
+    (publish
+      (local.get $x)
+    )
+  )
+
+  ;; CHECK:      (func $publish-shared-struct (type $5) (param $x (ref null $shared-struct)) (result (ref null $shared-struct))
+  ;; CHECK-NEXT:  (publish
+  ;; CHECK-NEXT:   (local.get $x)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  ;; RTRIP:      (func $publish-shared-struct (type $5) (param $x (ref null $shared-struct)) (result (ref null $shared-struct))
+  ;; RTRIP-NEXT:  (publish
+  ;; RTRIP-NEXT:   (local.get $x)
+  ;; RTRIP-NEXT:  )
+  ;; RTRIP-NEXT: )
+  (func $publish-shared-struct (param $x (ref null $shared-struct)) (result (ref null $shared-struct))
+    (publish
+      (local.get $x)
+    )
+  )
+
+  ;; CHECK:      (func $publish-array (type $6) (param $x (ref $array)) (result (ref $array))
+  ;; CHECK-NEXT:  (publish
+  ;; CHECK-NEXT:   (local.get $x)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  ;; RTRIP:      (func $publish-array (type $6) (param $x (ref $array)) (result (ref $array))
+  ;; RTRIP-NEXT:  (publish
+  ;; RTRIP-NEXT:   (local.get $x)
+  ;; RTRIP-NEXT:  )
+  ;; RTRIP-NEXT: )
+  (func $publish-array (param $x (ref $array)) (result (ref $array))
+    (publish
+      (local.get $x)
+    )
+  )
+
+  ;; CHECK:      (func $publish-shared-array (type $7) (param $x (ref null $shared-array)) (result (ref null $shared-array))
+  ;; CHECK-NEXT:  (publish
+  ;; CHECK-NEXT:   (local.get $x)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  ;; RTRIP:      (func $publish-shared-array (type $7) (param $x (ref null $shared-array)) (result (ref null $shared-array))
+  ;; RTRIP-NEXT:  (publish
+  ;; RTRIP-NEXT:   (local.get $x)
+  ;; RTRIP-NEXT:  )
+  ;; RTRIP-NEXT: )
+  (func $publish-shared-array (param $x (ref null $shared-array)) (result (ref null $shared-array))
+    (publish
+      (local.get $x)
+    )
+  )
+
+  ;; CHECK:      (func $publish-any (type $8) (param $x anyref) (result anyref)
+  ;; CHECK-NEXT:  (publish
+  ;; CHECK-NEXT:   (local.get $x)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  ;; RTRIP:      (func $publish-any (type $8) (param $x anyref) (result anyref)
+  ;; RTRIP-NEXT:  (publish
+  ;; RTRIP-NEXT:   (local.get $x)
+  ;; RTRIP-NEXT:  )
+  ;; RTRIP-NEXT: )
+  (func $publish-any (param $x anyref) (result anyref)
+    (publish
+      (local.get $x)
+    )
+  )
+
+  ;; CHECK:      (func $publish-eq (type $9) (param $x eqref) (result eqref)
+  ;; CHECK-NEXT:  (publish
+  ;; CHECK-NEXT:   (local.get $x)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  ;; RTRIP:      (func $publish-eq (type $9) (param $x eqref) (result eqref)
+  ;; RTRIP-NEXT:  (publish
+  ;; RTRIP-NEXT:   (local.get $x)
+  ;; RTRIP-NEXT:  )
+  ;; RTRIP-NEXT: )
+  (func $publish-eq (param $x eqref) (result eqref)
+    (publish
+      (local.get $x)
+    )
+  )
+
+  ;; CHECK:      (func $publish-i31 (type $10) (param $x (ref i31)) (result (ref i31))
+  ;; CHECK-NEXT:  (publish
+  ;; CHECK-NEXT:   (local.get $x)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  ;; RTRIP:      (func $publish-i31 (type $10) (param $x (ref i31)) (result (ref i31))
+  ;; RTRIP-NEXT:  (publish
+  ;; RTRIP-NEXT:   (local.get $x)
+  ;; RTRIP-NEXT:  )
+  ;; RTRIP-NEXT: )
+  (func $publish-i31 (param $x (ref i31)) (result (ref i31))
+    (publish
+      (local.get $x)
+    )
+  )
+
+  ;; CHECK:      (func $publish-extern (type $11) (param $x externref) (result externref)
+  ;; CHECK-NEXT:  (publish
+  ;; CHECK-NEXT:   (local.get $x)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  ;; RTRIP:      (func $publish-extern (type $11) (param $x externref) (result externref)
+  ;; RTRIP-NEXT:  (publish
+  ;; RTRIP-NEXT:   (local.get $x)
+  ;; RTRIP-NEXT:  )
+  ;; RTRIP-NEXT: )
+  (func $publish-extern (param $x externref) (result externref)
+    (publish
+      (local.get $x)
+    )
+  )
+
+  ;; CHECK:      (func $publish-func (type $12) (param $x funcref) (result funcref)
+  ;; CHECK-NEXT:  (publish
+  ;; CHECK-NEXT:   (local.get $x)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  ;; RTRIP:      (func $publish-func (type $12) (param $x funcref) (result funcref)
+  ;; RTRIP-NEXT:  (publish
+  ;; RTRIP-NEXT:   (local.get $x)
+  ;; RTRIP-NEXT:  )
+  ;; RTRIP-NEXT: )
+  (func $publish-func (param $x funcref) (result funcref)
+    (publish
+      (local.get $x)
+    )
+  )
+
+  ;; CHECK:      (func $publish-null (type $13) (param $x nullref) (result nullref)
+  ;; CHECK-NEXT:  (publish
+  ;; CHECK-NEXT:   (local.get $x)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  ;; RTRIP:      (func $publish-null (type $13) (param $x nullref) (result nullref)
+  ;; RTRIP-NEXT:  (publish
+  ;; RTRIP-NEXT:   (local.get $x)
+  ;; RTRIP-NEXT:  )
+  ;; RTRIP-NEXT: )
+  (func $publish-null (param $x nullref) (result nullref)
+    (publish
+      (local.get $x)
+    )
+  )
+
+  ;; CHECK:      (func $publish-flat (type $14) (param $x (ref any)) (result (ref any))
+  ;; CHECK-NEXT:  (publish
+  ;; CHECK-NEXT:   (local.get $x)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  ;; RTRIP:      (func $publish-flat (type $14) (param $x (ref any)) (result (ref any))
+  ;; RTRIP-NEXT:  (publish
+  ;; RTRIP-NEXT:   (local.get $x)
+  ;; RTRIP-NEXT:  )
+  ;; RTRIP-NEXT: )
+  (func $publish-flat (param $x (ref any)) (result (ref any))
+    (local.get $x)
+    (publish)
+  )
+
+  ;; CHECK:      (func $publish-unreachable (type $15) (result (ref any))
+  ;; CHECK-NEXT:  (publish
+  ;; CHECK-NEXT:   (unreachable)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  ;; RTRIP:      (func $publish-unreachable (type $15) (result (ref any))
+  ;; RTRIP-NEXT:  (unreachable)
+  ;; RTRIP-NEXT: )
+  (func $publish-unreachable (result (ref any))
+    (unreachable)
+    (publish)
+  )
+)
diff --git a/test/lit/scripts/extract_wasms.lit b/test/lit/scripts/extract_wasms.lit
index fee45071bbd..70cc59b4a59 100644
--- a/test/lit/scripts/extract_wasms.lit
+++ b/test/lit/scripts/extract_wasms.lit
@@ -6,7 +6,7 @@
 ;; A difference in the second byte, so we won't.
 ;; RUN: echo "bad1(new Uint8Array([0x00, 0xff, 0x73, 0x6D, 0x01]));" >> %t.js
 
-;; The last byte is unparseable as an integer, so we won't.
+;; The last byte is unparsable as an integer, so we won't.
 ;; RUN: echo "bad2(new Uint8Array([0x00, 0x61, 0x73, 0x6D, 6Dx0]));" >> %t.js
 
 ;; This is not a Uint8Array, so we do nothing.
diff --git a/test/lit/validation/publish.wast b/test/lit/validation/publish.wast
new file mode 100644
index 00000000000..5aa2216e877
--- /dev/null
+++ b/test/lit/validation/publish.wast
@@ -0,0 +1,21 @@
+;; RUN: not wasm-opt --enable-reference-types --enable-gc %s 2>&1 | filecheck %s --check-prefix=NO-SHARED
+;; RUN: not wasm-opt -all %s 2>&1 | filecheck %s --check-prefix=INVALID-TYPE
+
+;; Tests feature and type validations for publish.
+(module
+  (type $struct (struct (field i32)))
+
+  ;; NO-SHARED: publish requires shared-everything [--enable-shared-everything]
+  (func $no-feature (param $x (ref $struct)) (result (ref $struct))
+    (publish
+      (local.get $x)
+    )
+  )
+
+  ;; INVALID-TYPE: publish's argument should be a reference type
+  (func $bad-arg (param $x i32) (result i32)
+    (publish
+      (local.get $x)
+    )
+  )
+)
diff --git a/test/lit/wasm-split/multi-split2.wast b/test/lit/wasm-split/multi-split2.wast
index 9dc10461509..6a230faecd1 100644
--- a/test/lit/wasm-split/multi-split2.wast
+++ b/test/lit/wasm-split/multi-split2.wast
@@ -6,7 +6,7 @@
 ;; RUN: wasm-dis %t2.wasm | filecheck %s --check-prefix=MOD2
 ;; RUN: wasm-dis %t3.wasm | filecheck %s --check-prefix=MOD3
 
-;; A regresion test for the case the dispatch table was not correctly shared
+;; A regression test for the case the dispatch table was not correctly shared
 ;; with MOD1. Because func $A is not called by any function, MOD1 is a secondary
 ;; module who only acts as a caller.
 
diff --git a/test/lit/wasm-split/passive-deps.wast b/test/lit/wasm-split/passive-deps.wast
index 9007cb6081a..9c14bb09e98 100644
--- a/test/lit/wasm-split/passive-deps.wast
+++ b/test/lit/wasm-split/passive-deps.wast
@@ -1,38 +1,39 @@
-;; NOTE: Assertions have been generated by update_lit_checks.py --all-items and should not be edited.
 ;; RUN: wasm-split %s -all -g -o1 %t.1.wasm -o2 %t.2.wasm --split-funcs=split
 ;; RUN: wasm-dis -all %t.1.wasm | filecheck %s --check-prefix PRIMARY
 ;; RUN: wasm-dis -all %t.2.wasm | filecheck %s --check-prefix SECONDARY
 
 (module
- ;; PRIMARY:      (type $0 (func))
-
- ;; PRIMARY:      (global $g funcref (ref.null nofunc))
  (global $g funcref (ref.null nofunc))
 
  ;; We should scan this passive element segment's data and correctly mark $g as
  ;; used in the primary module.
- ;; PRIMARY:      (elem $passive-elem funcref (item (global.get $g)))
  (elem $passive-elem funcref (item (global.get $g)))
 
- ;; PRIMARY:      (export "global" (global $g))
-
- ;; PRIMARY:      (func $keep (type $0)
- ;; PRIMARY-NEXT:  (elem.drop $passive-elem)
- ;; PRIMARY-NEXT: )
  (func $keep
   (elem.drop $passive-elem)
  )
 
- ;; SECONDARY:      (type $0 (func))
-
- ;; SECONDARY:      (import "primary" "global" (global $g funcref))
-
- ;; SECONDARY:      (func $split (type $0)
- ;; SECONDARY-NEXT:  (drop
- ;; SECONDARY-NEXT:   (global.get $g)
- ;; SECONDARY-NEXT:  )
- ;; SECONDARY-NEXT: )
  (func $split
   (drop (global.get $g))
  )
 )
+
+;; PRIMARY:      (module
+;; PRIMARY-NEXT:  (type $0 (func))
+;; PRIMARY-NEXT:  (global $g funcref (ref.null nofunc))
+;; PRIMARY-NEXT:  (elem $passive-elem funcref (item (global.get $g)))
+;; PRIMARY-NEXT:  (export "global" (global $g))
+;; PRIMARY-NEXT:  (func $keep (type $0)
+;; PRIMARY-NEXT:   (elem.drop $passive-elem)
+;; PRIMARY-NEXT:  )
+;; PRIMARY-NEXT: )
+
+;; SECONDARY:      (module
+;; SECONDARY-NEXT:  (type $0 (func))
+;; SECONDARY-NEXT:  (import "primary" "global" (global $g funcref))
+;; SECONDARY-NEXT:  (func $split (type $0)
+;; SECONDARY-NEXT:   (drop
+;; SECONDARY-NEXT:    (global.get $g)
+;; SECONDARY-NEXT:   )
+;; SECONDARY-NEXT:  )
+;; SECONDARY-NEXT: )
diff --git a/test/lit/wasm-split/split-module-items.wast b/test/lit/wasm-split/split-module-items.wast
index 3816b50ce9b..b4a8b3db881 100644
--- a/test/lit/wasm-split/split-module-items.wast
+++ b/test/lit/wasm-split/split-module-items.wast
@@ -19,7 +19,8 @@
  ;; This is only used in the secondary module, but segments $keep-data2 can trap
  ;; so it is pinned to the primary, so this will be too.
  (memory $keep-memory2 1 1)
- (global $keep-global i32 (i32.const 20))
+ (global $keep-immutable-global i32 (i32.const 20))
+ (global $keep-mutable-global (mut i32) (i32.const 20))
  (table $keep-table 1 1 funcref)
  ;; This is only used in the secondary module, but segments $keep-elem2 and
  ;; $keep-elem3 can trap so they are pinned to the primary, so this will be too.
@@ -35,21 +36,25 @@
  (data $keep-data2 (memory $keep-memory2) (i32.const 65536) "a")
 
  (memory $split-memory 1 1)
- (global $split-global i32 (i32.const 20))
+ (global $split-immutable-global i32 (i32.const 20))
+ (global $split-mutable-global (mut i32) (i32.const 20))
  (table $split-table 1 1 funcref)
  (tag $split-tag (param i32))
  (elem $split-elem (table $split-table) (i32.const 0) funcref (item (ref.null nofunc)))
  (data $split-data (memory $split-memory) (i32.const 0) "a")
 
  (memory $shared-memory 1 1)
- (global $shared-global i32 (i32.const 20))
+ (global $shared-immutable-global i32 (i32.const 20))
+ (global $shared-mutable-global (mut i32) (i32.const 20))
  (table $shared-table 1 1 funcref)
  (tag $shared-tag (param i32))
  (elem $shared-elem (table $shared-table) (i32.const 0) funcref (item (ref.null nofunc)))
  (data $shared-data (memory $shared-memory) (i32.const 0) "a")
 
- ;; PRIMARY:      (global $keep-global i32 (i32.const 20))
- ;; PRIMARY-NEXT: (global $shared-global i32 (i32.const 20))
+ ;; PRIMARY:      (global $keep-immutable-global i32 (i32.const 20))
+ ;; PRIMARY-NEXT: (global $keep-mutable-global (mut i32) (i32.const 20))
+ ;; PRIMARY-NEXT: (global $shared-immutable-global i32 (i32.const 20))
+ ;; PRIMARY-NEXT: (global $shared-mutable-global (mut i32) (i32.const 20))
  ;; PRIMARY-NEXT: (memory $keep-memory 1 1)
  ;; PRIMARY-NEXT: (memory $keep-memory2 1 1)
  ;; PRIMARY-NEXT: (memory $shared-memory 1 1)
@@ -73,21 +78,24 @@
  ;; PRIMARY-NEXT: (export "memory_1" (memory $shared-memory))
  ;; PRIMARY-NEXT: (export "table" (table $keep-table2))
  ;; PRIMARY-NEXT: (export "table_3" (table $shared-table))
- ;; PRIMARY-NEXT: (export "global" (global $shared-global))
+ ;; PRIMARY-NEXT: (export "global" (global $shared-immutable-global))
+ ;; PRIMARY-NEXT: (export "global_5" (global $shared-mutable-global))
  ;; PRIMARY-NEXT: (export "tag" (tag $shared-tag))
  ;; PRIMARY-NEXT: (export "keep" (func $keep))
- ;; PRIMARY-NEXT: (export "table_7" (table $3))
+ ;; PRIMARY-NEXT: (export "table_8" (table $3))
 
  ;; SECONDARY:      (import "primary" "memory" (memory $keep-memory2 1 1))
  ;; SECONDARY-NEXT: (import "primary" "memory_1" (memory $shared-memory 1 1))
  ;; SECONDARY-NEXT: (import "primary" "table" (table $keep-table2 1 1 (ref null $2)))
  ;; SECONDARY-NEXT: (import "primary" "table_3" (table $shared-table 1 1 funcref))
- ;; SECONDARY-NEXT: (import "primary" "table_7" (table $timport$2 1 funcref))
- ;; SECONDARY-NEXT: (import "primary" "global" (global $shared-global i32))
+ ;; SECONDARY-NEXT: (import "primary" "table_8" (table $timport$2 1 funcref))
+ ;; SECONDARY-NEXT: (import "primary" "global" (global $shared-immutable-global i32))
+ ;; SECONDARY-NEXT: (import "primary" "global_5" (global $shared-mutable-global (mut i32)))
  ;; SECONDARY-NEXT: (import "primary" "keep" (func $keep (exact (param i32) (result i32))))
  ;; SECONDARY-NEXT: (import "primary" "tag" (tag $shared-tag (type $1) (param i32)))
 
- ;; SECONDARY:      (global $split-global i32 (i32.const 20))
+ ;; SECONDARY:      (global $split-immutable-global i32 (i32.const 20))
+ ;; SECONDARY-NEXT: (global $split-mutable-global (mut i32) (i32.const 20))
  ;; SECONDARY-NEXT: (memory $split-memory 1 1)
  ;; SECONDARY-NEXT: (data $split-data (memory $split-memory) (i32.const 0) "a")
  ;; SECONDARY-NEXT: (table $split-table 1 1 funcref)
@@ -109,9 +117,12 @@
     (i32.const 0)
    )
   )
-  ;; Uses $keep-global
+  ;; Uses $keep-immutable-global and $keep-mutable-global
   (drop
-   (global.get $keep-global)
+   (global.get $keep-immutable-global)
+  )
+  (drop
+   (global.get $keep-mutable-global)
   )
   ;; Uses $keep-tag
   (try_table (catch $keep-tag 0)
@@ -130,9 +141,12 @@
     (i32.const 0)
    )
   )
-  ;; Uses $shared-global
+  ;; Uses $shared-immutable-global and $shared-mutable-global
+  (drop
+   (global.get $shared-immutable-global)
+  )
   (drop
-   (global.get $shared-global)
+   (global.get $shared-mutable-global)
   )
   ;; Uses $shared-tag
   (try_table (catch $shared-tag 0)
@@ -166,9 +180,12 @@
   (drop
    (table.get $keep-table2 (i32.const 0))
   )
-  ;; Uses $split-global
+  ;; Uses $split-immutable-global and $shared-mutable-global
   (drop
-   (global.get $split-global)
+   (global.get $split-immutable-global)
+  )
+  (drop
+   (global.get $split-mutable-global)
   )
   ;; Uses $split-tag
   (try_table (catch $split-tag 0)
@@ -187,9 +204,12 @@
     (i32.const 0)
    )
   )
-  ;; Uses $shared-global
+  ;; Uses $shared-immutable-global and $shared-mutable-global
+  (drop
+   (global.get $shared-immutable-global)
+  )
   (drop
-   (global.get $shared-global)
+   (global.get $shared-mutable-global)
   )
   ;; Uses $shared-tag
   (try_table (catch $shared-tag 0)
diff --git a/test/lit/wasm-split/transitive-globals-multi.wast b/test/lit/wasm-split/transitive-globals-multi.wast
deleted file mode 100644
index f9eda9a7d59..00000000000
--- a/test/lit/wasm-split/transitive-globals-multi.wast
+++ /dev/null
@@ -1,52 +0,0 @@
-;; NOTE: Assertions have been generated by update_lit_checks.py --all-items and should not be edited.
-;; RUN: wasm-split -all -g --multi-split %s --manifest %s.manifest --out-prefix=%t -o %t.wasm
-;; RUN: wasm-dis %t.wasm | filecheck %s --check-prefix PRIMARY
-;; RUN: wasm-dis %t1.wasm | filecheck %s --check-prefix SECONDARY1
-;; RUN: wasm-dis %t2.wasm | filecheck %s --check-prefix SECONDARY2
-
-;; Because global $e is used in both module1 ($split1) and module2 ($split2), $e
-;; will be exported / imported, but we don't need to export $f.
-
-(module
-  ;; PRIMARY:      (type $0 (func))
-
-  ;; PRIMARY:      (global $f i32 (i32.const 42))
-  (global $f i32 (i32.const 42))
-  ;; PRIMARY:      (global $e i32 (global.get $f))
-  (global $e i32 (global.get $f))
-
-  ;; PRIMARY:      (export "global" (global $e))
-
-  ;; PRIMARY:      (func $keep
-  ;; PRIMARY-NEXT:  (nop)
-  ;; PRIMARY-NEXT: )
-  (func $keep
-    (nop)
-  )
-
-  ;; SECONDARY1:      (type $0 (func))
-
-  ;; SECONDARY1:      (import "primary" "global" (global $e i32))
-
-  ;; SECONDARY1:      (func $split1
-  ;; SECONDARY1-NEXT:  (drop
-  ;; SECONDARY1-NEXT:   (global.get $e)
-  ;; SECONDARY1-NEXT:  )
-  ;; SECONDARY1-NEXT: )
-  (func $split1
-    (drop (global.get $e))
-  )
-
-  ;; SECONDARY2:      (type $0 (func))
-
-  ;; SECONDARY2:      (import "primary" "global" (global $e i32))
-
-  ;; SECONDARY2:      (func $split2
-  ;; SECONDARY2-NEXT:  (drop
-  ;; SECONDARY2-NEXT:   (global.get $e)
-  ;; SECONDARY2-NEXT:  )
-  ;; SECONDARY2-NEXT: )
-  (func $split2
-    (drop (global.get $e))
-  )
-)
diff --git a/test/lit/wasm-split/transitive-globals.wast b/test/lit/wasm-split/transitive-globals.wast
index a277ec72605..ad702a4363b 100644
--- a/test/lit/wasm-split/transitive-globals.wast
+++ b/test/lit/wasm-split/transitive-globals.wast
@@ -19,29 +19,10 @@
   (global $e i32 (global.get $f))
   (global $d i32 (global.get $e))
 
-  ;; PRIMARY:      (global $f i32 (i32.const 42))
-  ;; PRIMARY:      (global $e i32 (global.get $f))
-
-  ;; PRIMARY:      (export "global" (global $e))
-
-  ;; SECONDARY:      (import "primary" "global" (global $e i32))
-
-  ;; SECONDARY:      (global $c i32 (i32.const 42))
-  ;; SECONDARY:      (global $b i32 (global.get $c))
-  ;; SECONDARY:      (global $a i32 (global.get $b))
-
-  ;; SECONDARY:      (global $d i32 (global.get $e))
-
   ;; This dead global is referring to a global ($a) that's moved to the
   ;; secondary module. This should be deleted.
-  ;; PRIMARY-NOT:  (global (global $dead i32 (global.get $a))
   (global $dead i32 (global.get $a))
 
-  ;; PRIMARY:      (func $keep
-  ;; PRIMARY-NEXT:  (drop
-  ;; PRIMARY-NEXT:   (global.get $e)
-  ;; PRIMARY-NEXT:  )
-  ;; PRIMARY-NEXT: )
   (func $keep
     (drop
       (global.get $e)
@@ -49,14 +30,6 @@
   )
 
   ;; Exclusively uses $a and $d, causing them to move to the secondary module
-  ;; SECONDARY:      (func $split
-  ;; SECONDARY-NEXT:  (drop
-  ;; SECONDARY-NEXT:   (global.get $a)
-  ;; SECONDARY-NEXT:  )
-  ;; SECONDARY-NEXT:  (drop
-  ;; SECONDARY-NEXT:   (global.get $d)
-  ;; SECONDARY-NEXT:  )
-  ;; SECONDARY-NEXT: )
   (func $split
     (drop
       (global.get $a)
@@ -66,3 +39,32 @@
     )
   )
 )
+
+;; PRIMARY:      (module
+;; PRIMARY-NEXT:  (type $0 (func))
+;; PRIMARY-NEXT:  (global $f i32 (i32.const 42))
+;; PRIMARY-NEXT:  (global $e i32 (global.get $f))
+;; PRIMARY-NEXT:  (export "global" (global $e))
+;; PRIMARY-NEXT:  (func $keep
+;; PRIMARY-NEXT:   (drop
+;; PRIMARY-NEXT:    (global.get $e)
+;; PRIMARY-NEXT:   )
+;; PRIMARY-NEXT:  )
+;; PRIMARY-NEXT: )
+
+;; SECONDARY:      (module
+;; SECONDARY-NEXT:  (type $0 (func))
+;; SECONDARY-NEXT:  (import "primary" "global" (global $e i32))
+;; SECONDARY-NEXT:  (global $c i32 (i32.const 42))
+;; SECONDARY-NEXT:  (global $b i32 (global.get $c))
+;; SECONDARY-NEXT:  (global $a i32 (global.get $b))
+;; SECONDARY-NEXT:  (global $d i32 (global.get $e))
+;; SECONDARY-NEXT:  (func $split
+;; SECONDARY-NEXT:   (drop
+;; SECONDARY-NEXT:    (global.get $a)
+;; SECONDARY-NEXT:   )
+;; SECONDARY-NEXT:   (drop
+;; SECONDARY-NEXT:    (global.get $d)
+;; SECONDARY-NEXT:   )
+;; SECONDARY-NEXT:  )
+;; SECONDARY-NEXT: )
diff --git a/test/lit/wasm-split/transitive-immutable-globals-multi.wast b/test/lit/wasm-split/transitive-immutable-globals-multi.wast
new file mode 100644
index 00000000000..3f2cb97c392
--- /dev/null
+++ b/test/lit/wasm-split/transitive-immutable-globals-multi.wast
@@ -0,0 +1,54 @@
+;; RUN: wasm-split -all -g --multi-split %s --manifest %S/transitive-globals-multi.wast.manifest --out-prefix=%t -o %t.wasm
+;; RUN: wasm-dis -all %t.wasm | filecheck %s --check-prefix PRIMARY
+;; RUN: wasm-dis -all %t1.wasm | filecheck %s --check-prefix SECONDARY1
+;; RUN: wasm-dis -all %t2.wasm | filecheck %s --check-prefix SECONDARY2
+
+;; Because global $e is used in both module1 ($split1) and module2 ($split2), $e
+;; will be exported / imported, but we don't need to export $f.
+
+(module
+  (global $f i32 (i32.const 42))
+  (global $e i32 (global.get $f))
+
+  (func $keep
+    (nop)
+  )
+
+  (func $split1
+    (drop (global.get $e))
+  )
+
+  (func $split2
+    (drop (global.get $e))
+  )
+)
+
+;; PRIMARY:      (module
+;; PRIMARY-NEXT:  (type $0 (func))
+;; PRIMARY-NEXT:  (global $f i32 (i32.const 42))
+;; PRIMARY-NEXT:  (global $e i32 (global.get $f))
+;; PRIMARY-NEXT:  (export "global" (global $e))
+;; PRIMARY-NEXT:  (func $keep (type $0)
+;; PRIMARY-NEXT:   (nop)
+;; PRIMARY-NEXT:  )
+;; PRIMARY-NEXT: )
+
+;; SECONDARY1:      (module
+;; SECONDARY1-NEXT:  (type $0 (func))
+;; SECONDARY1-NEXT:  (import "primary" "global" (global $e i32))
+;; SECONDARY1-NEXT:  (func $split1 (type $0)
+;; SECONDARY1-NEXT:   (drop
+;; SECONDARY1-NEXT:    (global.get $e)
+;; SECONDARY1-NEXT:   )
+;; SECONDARY1-NEXT:  )
+;; SECONDARY1-NEXT: )
+
+;; SECONDARY2:      (module
+;; SECONDARY2-NEXT:  (type $0 (func))
+;; SECONDARY2-NEXT:  (import "primary" "global" (global $e i32))
+;; SECONDARY2-NEXT:  (func $split2 (type $0)
+;; SECONDARY2-NEXT:   (drop
+;; SECONDARY2-NEXT:    (global.get $e)
+;; SECONDARY2-NEXT:   )
+;; SECONDARY2-NEXT:  )
+;; SECONDARY2-NEXT: )
diff --git a/test/lit/wasm-split/transitive-mutable-globals-multi.wast b/test/lit/wasm-split/transitive-mutable-globals-multi.wast
new file mode 100644
index 00000000000..1b297267fd0
--- /dev/null
+++ b/test/lit/wasm-split/transitive-mutable-globals-multi.wast
@@ -0,0 +1,54 @@
+;; RUN: wasm-split -all -g --multi-split %s --manifest %S/transitive-globals-multi.wast.manifest --out-prefix=%t -o %t.wasm
+;; RUN: wasm-dis -all %t.wasm | filecheck %s --check-prefix PRIMARY
+;; RUN: wasm-dis -all %t1.wasm | filecheck %s --check-prefix SECONDARY1
+;; RUN: wasm-dis -all %t2.wasm | filecheck %s --check-prefix SECONDARY2
+
+;; Because global $e is used in both module1 ($split1) and module2 ($split2), $e
+;; will be exported / imported, but we don't need to export $f.
+
+(module
+  (global $f i32 (i32.const 42))
+  (global $e (mut i32) (global.get $f))
+
+  (func $keep
+    (nop)
+  )
+
+  (func $split1
+    (drop (global.get $e))
+  )
+
+  (func $split2
+    (drop (global.get $e))
+  )
+)
+
+;; PRIMARY:      (module
+;; PRIMARY-NEXT:  (type $0 (func))
+;; PRIMARY-NEXT:  (global $f i32 (i32.const 42))
+;; PRIMARY-NEXT:  (global $e (mut i32) (global.get $f))
+;; PRIMARY-NEXT:  (export "global" (global $e))
+;; PRIMARY-NEXT:  (func $keep (type $0)
+;; PRIMARY-NEXT:   (nop)
+;; PRIMARY-NEXT:  )
+;; PRIMARY-NEXT: )
+
+;; SECONDARY1:      (module
+;; SECONDARY1-NEXT:  (type $0 (func))
+;; SECONDARY1-NEXT:  (import "primary" "global" (global $e (mut i32)))
+;; SECONDARY1-NEXT:  (func $split1 (type $0)
+;; SECONDARY1-NEXT:   (drop
+;; SECONDARY1-NEXT:    (global.get $e)
+;; SECONDARY1-NEXT:   )
+;; SECONDARY1-NEXT:  )
+;; SECONDARY1-NEXT: )
+
+;; SECONDARY2:      (module
+;; SECONDARY2-NEXT:  (type $0 (func))
+;; SECONDARY2-NEXT:  (import "primary" "global" (global $e (mut i32)))
+;; SECONDARY2-NEXT:  (func $split2 (type $0)
+;; SECONDARY2-NEXT:   (drop
+;; SECONDARY2-NEXT:    (global.get $e)
+;; SECONDARY2-NEXT:   )
+;; SECONDARY2-NEXT:  )
+;; SECONDARY2-NEXT: )
diff --git a/test/passes/fannkuch3_manyopts_dwarf.bin.txt b/test/passes/fannkuch3_manyopts_dwarf.bin.txt
index 0f159c3feff..b6fd3128e21 100644
--- a/test/passes/fannkuch3_manyopts_dwarf.bin.txt
+++ b/test/passes/fannkuch3_manyopts_dwarf.bin.txt
@@ -2303,7 +2303,7 @@ Contains section .debug_info (851 bytes)
 Contains section .debug_loc (1073 bytes)
 Contains section .debug_ranges (88 bytes)
 Contains section .debug_abbrev (333 bytes)
-Contains section .debug_line (2322 bytes)
+Contains section .debug_line (2300 bytes)
 Contains section .debug_str (434 bytes)
 
 .debug_abbrev contents:
@@ -2470,7 +2470,7 @@ Abbrev table for offset: 0x00000000
               DW_AT_low_pc [DW_FORM_addr]	(0x0000000000000000)
               DW_AT_ranges [DW_FORM_sec_offset]	(0x00000040
                  [0x00000006, 0x00000377)
-                 [0x00000379, 0x000005a8))
+                 [0x00000379, 0x00000588))
 
 0x00000026:   DW_TAG_pointer_type [2]  
                 DW_AT_type [DW_FORM_ref4]	(cu + 0x002b => {0x0000002b} "worker_args")
@@ -2818,7 +2818,7 @@ Abbrev table for offset: 0x00000000
 
 0x0000023b:   DW_TAG_subprogram [23] *
                 DW_AT_low_pc [DW_FORM_addr]	(0x0000000000000379)
-                DW_AT_high_pc [DW_FORM_data4]	(0x0000022f)
+                DW_AT_high_pc [DW_FORM_data4]	(0x0000020f)
                 DW_AT_frame_base [DW_FORM_exprloc]	(DW_OP_WASM_location 0x0 +2, DW_OP_stack_value)
                 DW_AT_GNU_all_call_sites [DW_FORM_flag_present]	(true)
                 DW_AT_name [DW_FORM_strp]	( .debug_str[0x0000018c] = "main")
@@ -2867,7 +2867,7 @@ Abbrev table for offset: 0x00000000
 
 0x00000296:       DW_TAG_variable [26]  
                     DW_AT_location [DW_FORM_sec_offset]	(0x000002a2: 
-                       [0xffffffff,  0x0000056d): 
+                       [0xffffffff,  0x0000054d): 
                        [0x00000001,  0x00000001): DW_OP_lit0, DW_OP_stack_value
                        [0x00000000,  0x00000018): DW_OP_WASM_location 0x0 +6, DW_OP_stack_value)
                     DW_AT_abstract_origin [DW_FORM_ref4]	(cu + 0x01ce => {0x000001ce} "args")
@@ -2878,9 +2878,9 @@ Abbrev table for offset: 0x00000000
                        [0x00000001,  0x00000001): DW_OP_consts +0, DW_OP_stack_value
                        [0x00000000,  0x00000005): DW_OP_WASM_location 0x0 +0, DW_OP_stack_value
                        [0x00000001,  0x00000001): DW_OP_consts +0, DW_OP_stack_value
-                       [0x0000003f,  0x00000044): DW_OP_WASM_location 0x0 +0, DW_OP_stack_value
-                       [0x0000005d,  0x00000061): DW_OP_consts +0, DW_OP_stack_value
-                       [0x00000088,  0x0000008d): DW_OP_WASM_location 0x0 +0, DW_OP_stack_value
+                       [0x00000036,  0x0000003b): DW_OP_WASM_location 0x0 +0, DW_OP_stack_value
+                       [0x00000049,  0x0000004d): DW_OP_consts +0, DW_OP_stack_value
+                       [0x00000074,  0x00000079): DW_OP_WASM_location 0x0 +0, DW_OP_stack_value
                        [0x00000001,  0x00000001): DW_OP_consts +0, DW_OP_stack_value
                        [0x00000001,  0x00000001): DW_OP_consts +0, DW_OP_stack_value
                        [0x00000001,  0x00000001): DW_OP_consts +0, DW_OP_stack_value)
@@ -2903,31 +2903,31 @@ Abbrev table for offset: 0x00000000
 
 0x000002bf:       DW_TAG_variable [26]  
                     DW_AT_location [DW_FORM_sec_offset]	(0x00000390: 
-                       [0xffffffff,  0x0000052d): 
+                       [0xffffffff,  0x00000519): 
                        [0x00000000,  0x00000007): DW_OP_WASM_location 0x0 +6, DW_OP_stack_value
                        [0x00000001,  0x00000001): DW_OP_WASM_location 0x0 +6, DW_OP_stack_value)
                     DW_AT_abstract_origin [DW_FORM_ref4]	(cu + 0x0205 => {0x00000205} "r")
 
 0x000002c8:       DW_TAG_variable [26]  
                     DW_AT_location [DW_FORM_sec_offset]	(0x000003e8: 
-                       [0xffffffff,  0x00000556): 
+                       [0xffffffff,  0x00000536): 
                        [0x00000001,  0x00000001): DW_OP_consts +0, DW_OP_stack_value
                        [0x00000027,  0x0000002f): DW_OP_WASM_location 0x0 +0, DW_OP_stack_value)
                     DW_AT_abstract_origin [DW_FORM_ref4]	(cu + 0x0210 => {0x00000210} "maxflips")
 
 0x000002d1:       DW_TAG_variable [26]  
                     DW_AT_location [DW_FORM_sec_offset]	(0x00000413: 
-                       [0xffffffff,  0x00000566): 
+                       [0xffffffff,  0x00000546): 
                        [0x00000000,  0x0000001f): DW_OP_WASM_location 0x0 +1, DW_OP_stack_value)
                     DW_AT_abstract_origin [DW_FORM_ref4]	(cu + 0x021b => {0x0000021b} "flips")
 
 0x000002da:       DW_TAG_label [28]  
                     DW_AT_abstract_origin [DW_FORM_ref4]	(cu + 0x0226 => {0x00000226} "cleanup")
-                    DW_AT_low_pc [DW_FORM_addr]	(0x000000000000054a)
+                    DW_AT_low_pc [DW_FORM_addr]	(0x000000000000052a)
 
 0x000002e3:       DW_TAG_lexical_block [14] *
                     DW_AT_ranges [DW_FORM_sec_offset]	(0x00000028
-                       [0x000004c3, 0x00000508)
+                       [0x000004af, 0x000004f4)
                        [0x00000000, 0x00000001))
 
 0x000002e8:         DW_TAG_variable [26]  
@@ -2957,31 +2957,31 @@ Abbrev table for offset: 0x00000000
                   DW_AT_low_pc [DW_FORM_addr]	(0x000000000000040e)
 
 0x0000030c:     DW_TAG_GNU_call_site [15]  
-                  DW_AT_low_pc [DW_FORM_addr]	(0x0000000000000474)
+                  DW_AT_low_pc [DW_FORM_addr]	(0x0000000000000460)
 
 0x00000311:     DW_TAG_GNU_call_site [15]  
-                  DW_AT_low_pc [DW_FORM_addr]	(0x0000000000000486)
+                  DW_AT_low_pc [DW_FORM_addr]	(0x0000000000000472)
 
 0x00000316:     DW_TAG_GNU_call_site [15]  
-                  DW_AT_low_pc [DW_FORM_addr]	(0x0000000000000544)
+                  DW_AT_low_pc [DW_FORM_addr]	(0x0000000000000000)
 
 0x0000031b:     DW_TAG_GNU_call_site [16]  
                   DW_AT_abstract_origin [DW_FORM_ref4]	(cu + 0x019a => {0x0000019a} "free")
-                  DW_AT_low_pc [DW_FORM_addr]	(0x000000000000054e)
+                  DW_AT_low_pc [DW_FORM_addr]	(0x000000000000052e)
 
 0x00000324:     DW_TAG_GNU_call_site [16]  
                   DW_AT_abstract_origin [DW_FORM_ref4]	(cu + 0x019a => {0x0000019a} "free")
-                  DW_AT_low_pc [DW_FORM_addr]	(0x0000000000000552)
+                  DW_AT_low_pc [DW_FORM_addr]	(0x0000000000000532)
 
 0x0000032d:     DW_TAG_GNU_call_site [15]  
-                  DW_AT_low_pc [DW_FORM_addr]	(0x0000000000000564)
+                  DW_AT_low_pc [DW_FORM_addr]	(0x0000000000000544)
 
 0x00000332:     DW_TAG_GNU_call_site [16]  
                   DW_AT_abstract_origin [DW_FORM_ref4]	(cu + 0x019a => {0x0000019a} "free")
-                  DW_AT_low_pc [DW_FORM_addr]	(0x0000000000000571)
+                  DW_AT_low_pc [DW_FORM_addr]	(0x0000000000000551)
 
 0x0000033b:     DW_TAG_GNU_call_site [15]  
-                  DW_AT_low_pc [DW_FORM_addr]	(0x000000000000059c)
+                  DW_AT_low_pc [DW_FORM_addr]	(0x000000000000057c)
 
 0x00000340:     NULL
 
@@ -3073,7 +3073,7 @@ Abbrev table for offset: 0x00000000
             [0x00000001,  0x00000001): DW_OP_consts +30, DW_OP_stack_value
 
 0x000002a2: 
-            [0xffffffff,  0x0000056d): 
+            [0xffffffff,  0x0000054d): 
             [0x00000001,  0x00000001): DW_OP_lit0, DW_OP_stack_value
             [0x00000000,  0x00000018): DW_OP_WASM_location 0x0 +6, DW_OP_stack_value
 
@@ -3082,9 +3082,9 @@ Abbrev table for offset: 0x00000000
             [0x00000001,  0x00000001): DW_OP_consts +0, DW_OP_stack_value
             [0x00000000,  0x00000005): DW_OP_WASM_location 0x0 +0, DW_OP_stack_value
             [0x00000001,  0x00000001): DW_OP_consts +0, DW_OP_stack_value
-            [0x0000003f,  0x00000044): DW_OP_WASM_location 0x0 +0, DW_OP_stack_value
-            [0x0000005d,  0x00000061): DW_OP_consts +0, DW_OP_stack_value
-            [0x00000088,  0x0000008d): DW_OP_WASM_location 0x0 +0, DW_OP_stack_value
+            [0x00000036,  0x0000003b): DW_OP_WASM_location 0x0 +0, DW_OP_stack_value
+            [0x00000049,  0x0000004d): DW_OP_consts +0, DW_OP_stack_value
+            [0x00000074,  0x00000079): DW_OP_WASM_location 0x0 +0, DW_OP_stack_value
             [0x00000001,  0x00000001): DW_OP_consts +0, DW_OP_stack_value
             [0x00000001,  0x00000001): DW_OP_consts +0, DW_OP_stack_value
             [0x00000001,  0x00000001): DW_OP_consts +0, DW_OP_stack_value
@@ -3098,7 +3098,7 @@ Abbrev table for offset: 0x00000000
             [0x00000001,  0x00000001): DW_OP_WASM_location 0x0 +5, DW_OP_stack_value
 
 0x00000390: 
-            [0xffffffff,  0x0000052d): 
+            [0xffffffff,  0x00000519): 
             [0x00000000,  0x00000007): DW_OP_WASM_location 0x0 +6, DW_OP_stack_value
             [0x00000001,  0x00000001): DW_OP_WASM_location 0x0 +6, DW_OP_stack_value
 
@@ -3108,18 +3108,18 @@ Abbrev table for offset: 0x00000000
             [0x00000001,  0x00000001): DW_OP_WASM_location 0x0 +8, DW_OP_stack_value
 
 0x000003e8: 
-            [0xffffffff,  0x00000556): 
+            [0xffffffff,  0x00000536): 
             [0x00000001,  0x00000001): DW_OP_consts +0, DW_OP_stack_value
             [0x00000027,  0x0000002f): DW_OP_WASM_location 0x0 +0, DW_OP_stack_value
 
 0x00000413: 
-            [0xffffffff,  0x00000566): 
+            [0xffffffff,  0x00000546): 
             [0x00000000,  0x0000001f): DW_OP_WASM_location 0x0 +1, DW_OP_stack_value
 
 .debug_line contents:
 debug_line[0x00000000]
 Line table prologue:
-    total_length: 0x0000090e
+    total_length: 0x000008f8
          version: 4
  prologue_length: 0x000000dd
  min_inst_length: 1
@@ -4079,352 +4079,339 @@ file_names[  4]:
 
 
 0x000006d2: 00 DW_LNE_set_address (0x0000000000000416)
-0x000006d9: 03 DW_LNS_advance_line (105)
-0x000006db: 01 DW_LNS_copy
-            0x0000000000000416    105     18      1   0             0  is_stmt
+0x000006d9: 03 DW_LNS_advance_line (106)
+0x000006db: 05 DW_LNS_set_column (7)
+0x000006dd: 01 DW_LNS_copy
+            0x0000000000000416    106      7      1   0             0  is_stmt
 
 
-0x000006dc: 00 DW_LNE_set_address (0x000000000000041f)
-0x000006e3: 03 DW_LNS_advance_line (106)
-0x000006e5: 05 DW_LNS_set_column (7)
-0x000006e7: 01 DW_LNS_copy
-            0x000000000000041f    106      7      1   0             0  is_stmt
+0x000006de: 00 DW_LNE_set_address (0x000000000000041e)
+0x000006e5: 05 DW_LNS_set_column (16)
+0x000006e7: 06 DW_LNS_negate_stmt
+0x000006e8: 01 DW_LNS_copy
+            0x000000000000041e    106     16      1   0             0 
 
 
-0x000006e8: 00 DW_LNE_set_address (0x0000000000000427)
-0x000006ef: 05 DW_LNS_set_column (16)
-0x000006f1: 06 DW_LNS_negate_stmt
-0x000006f2: 01 DW_LNS_copy
-            0x0000000000000427    106     16      1   0             0 
+0x000006e9: 00 DW_LNE_set_address (0x0000000000000423)
+0x000006f0: 03 DW_LNS_advance_line (105)
+0x000006f2: 05 DW_LNS_set_column (24)
+0x000006f4: 06 DW_LNS_negate_stmt
+0x000006f5: 01 DW_LNS_copy
+            0x0000000000000423    105     24      1   0             0  is_stmt
 
 
-0x000006f3: 00 DW_LNE_set_address (0x000000000000042c)
-0x000006fa: 03 DW_LNS_advance_line (105)
-0x000006fc: 05 DW_LNS_set_column (24)
-0x000006fe: 06 DW_LNS_negate_stmt
-0x000006ff: 01 DW_LNS_copy
-            0x000000000000042c    105     24      1   0             0  is_stmt
+0x000006f6: 00 DW_LNE_set_address (0x0000000000000428)
+0x000006fd: 05 DW_LNS_set_column (18)
+0x000006ff: 06 DW_LNS_negate_stmt
+0x00000700: 01 DW_LNS_copy
+            0x0000000000000428    105     18      1   0             0 
 
 
-0x00000700: 00 DW_LNE_set_address (0x0000000000000431)
-0x00000707: 05 DW_LNS_set_column (18)
-0x00000709: 06 DW_LNS_negate_stmt
-0x0000070a: 01 DW_LNS_copy
-            0x0000000000000431    105     18      1   0             0 
+0x00000701: 00 DW_LNE_set_address (0x0000000000000443)
+0x00000708: 03 DW_LNS_advance_line (112)
+0x0000070a: 05 DW_LNS_set_column (13)
+0x0000070c: 06 DW_LNS_negate_stmt
+0x0000070d: 01 DW_LNS_copy
+            0x0000000000000443    112     13      1   0             0  is_stmt
 
 
-0x0000070b: 00 DW_LNE_set_address (0x0000000000000457)
-0x00000712: 03 DW_LNS_advance_line (112)
-0x00000714: 05 DW_LNS_set_column (13)
-0x00000716: 06 DW_LNS_negate_stmt
-0x00000717: 01 DW_LNS_copy
-            0x0000000000000457    112     13      1   0             0  is_stmt
+0x0000070e: 00 DW_LNE_set_address (0x0000000000000445)
+0x00000715: 05 DW_LNS_set_column (26)
+0x00000717: 06 DW_LNS_negate_stmt
+0x00000718: 01 DW_LNS_copy
+            0x0000000000000445    112     26      1   0             0 
 
 
-0x00000718: 00 DW_LNE_set_address (0x0000000000000459)
-0x0000071f: 05 DW_LNS_set_column (26)
-0x00000721: 06 DW_LNS_negate_stmt
+0x00000719: 00 DW_LNE_set_address (0x0000000000000452)
+0x00000720: 05 DW_LNS_set_column (35)
 0x00000722: 01 DW_LNS_copy
-            0x0000000000000459    112     26      1   0             0 
+            0x0000000000000452    112     35      1   0             0 
 
 
-0x00000723: 00 DW_LNE_set_address (0x0000000000000466)
-0x0000072a: 05 DW_LNS_set_column (35)
+0x00000723: 00 DW_LNE_set_address (0x0000000000000453)
+0x0000072a: 05 DW_LNS_set_column (13)
 0x0000072c: 01 DW_LNS_copy
-            0x0000000000000466    112     35      1   0             0 
+            0x0000000000000453    112     13      1   0             0 
 
 
-0x0000072d: 00 DW_LNE_set_address (0x0000000000000467)
-0x00000734: 05 DW_LNS_set_column (13)
-0x00000736: 01 DW_LNS_copy
-            0x0000000000000467    112     13      1   0             0 
+0x0000072d: 00 DW_LNE_set_address (0x0000000000000461)
+0x00000734: 03 DW_LNS_advance_line (111)
+0x00000736: 05 DW_LNS_set_column (30)
+0x00000738: 06 DW_LNS_negate_stmt
+0x00000739: 01 DW_LNS_copy
+            0x0000000000000461    111     30      1   0             0  is_stmt
 
 
-0x00000737: 00 DW_LNE_set_address (0x0000000000000475)
-0x0000073e: 03 DW_LNS_advance_line (111)
-0x00000740: 05 DW_LNS_set_column (30)
-0x00000742: 06 DW_LNS_negate_stmt
-0x00000743: 01 DW_LNS_copy
-            0x0000000000000475    111     30      1   0             0  is_stmt
+0x0000073a: 00 DW_LNE_set_address (0x0000000000000466)
+0x00000741: 05 DW_LNS_set_column (24)
+0x00000743: 06 DW_LNS_negate_stmt
+0x00000744: 01 DW_LNS_copy
+            0x0000000000000466    111     24      1   0             0 
 
 
-0x00000744: 00 DW_LNE_set_address (0x000000000000047a)
-0x0000074b: 05 DW_LNS_set_column (24)
-0x0000074d: 06 DW_LNS_negate_stmt
+0x00000745: 00 DW_LNE_set_address (0x000000000000046b)
+0x0000074c: 05 DW_LNS_set_column (10)
 0x0000074e: 01 DW_LNS_copy
-            0x000000000000047a    111     24      1   0             0 
+            0x000000000000046b    111     10      1   0             0 
 
 
-0x0000074f: 00 DW_LNE_set_address (0x000000000000047f)
-0x00000756: 05 DW_LNS_set_column (10)
-0x00000758: 01 DW_LNS_copy
-            0x000000000000047f    111     10      1   0             0 
+0x0000074f: 00 DW_LNE_set_address (0x0000000000000470)
+0x00000756: 03 DW_LNS_advance_line (113)
+0x00000758: 06 DW_LNS_negate_stmt
+0x00000759: 01 DW_LNS_copy
+            0x0000000000000470    113     10      1   0             0  is_stmt
 
 
-0x00000759: 00 DW_LNE_set_address (0x0000000000000484)
-0x00000760: 03 DW_LNS_advance_line (113)
-0x00000762: 06 DW_LNS_negate_stmt
-0x00000763: 01 DW_LNS_copy
-            0x0000000000000484    113     10      1   0             0  is_stmt
+0x0000075a: 00 DW_LNE_set_address (0x0000000000000473)
+0x00000761: 03 DW_LNS_advance_line (118)
+0x00000763: 05 DW_LNS_set_column (16)
+0x00000765: 01 DW_LNS_copy
+            0x0000000000000473    118     16      1   0             0  is_stmt
 
 
-0x00000764: 00 DW_LNE_set_address (0x0000000000000487)
-0x0000076b: 03 DW_LNS_advance_line (118)
-0x0000076d: 05 DW_LNS_set_column (16)
-0x0000076f: 01 DW_LNS_copy
-            0x0000000000000487    118     16      1   0             0  is_stmt
+0x00000766: 00 DW_LNE_set_address (0x000000000000047c)
+0x0000076d: 03 DW_LNS_advance_line (119)
+0x0000076f: 05 DW_LNS_set_column (10)
+0x00000771: 01 DW_LNS_copy
+            0x000000000000047c    119     10      1   0             0  is_stmt
 
 
-0x00000770: 00 DW_LNE_set_address (0x0000000000000490)
-0x00000777: 03 DW_LNS_advance_line (119)
-0x00000779: 05 DW_LNS_set_column (10)
-0x0000077b: 01 DW_LNS_copy
-            0x0000000000000490    119     10      1   0             0  is_stmt
+0x00000772: 00 DW_LNE_set_address (0x000000000000047e)
+0x00000779: 05 DW_LNS_set_column (18)
+0x0000077b: 06 DW_LNS_negate_stmt
+0x0000077c: 01 DW_LNS_copy
+            0x000000000000047e    119     18      1   0             0 
 
 
-0x0000077c: 00 DW_LNE_set_address (0x0000000000000492)
-0x00000783: 05 DW_LNS_set_column (18)
-0x00000785: 06 DW_LNS_negate_stmt
+0x0000077d: 00 DW_LNE_set_address (0x0000000000000487)
+0x00000784: 05 DW_LNS_set_column (10)
 0x00000786: 01 DW_LNS_copy
-            0x0000000000000492    119     18      1   0             0 
+            0x0000000000000487    119     10      1   0             0 
 
 
-0x00000787: 00 DW_LNE_set_address (0x000000000000049b)
-0x0000078e: 05 DW_LNS_set_column (10)
+0x00000787: 00 DW_LNE_set_address (0x0000000000000489)
+0x0000078e: 05 DW_LNS_set_column (23)
 0x00000790: 01 DW_LNS_copy
-            0x000000000000049b    119     10      1   0             0 
+            0x0000000000000489    119     23      1   0             0 
 
 
-0x00000791: 00 DW_LNE_set_address (0x000000000000049d)
-0x00000798: 05 DW_LNS_set_column (23)
-0x0000079a: 01 DW_LNS_copy
-            0x000000000000049d    119     23      1   0             0 
+0x00000791: 00 DW_LNE_set_address (0x000000000000048e)
+0x00000798: 03 DW_LNS_advance_line (118)
+0x0000079a: 05 DW_LNS_set_column (16)
+0x0000079c: 06 DW_LNS_negate_stmt
+0x0000079d: 01 DW_LNS_copy
+            0x000000000000048e    118     16      1   0             0  is_stmt
 
 
-0x0000079b: 00 DW_LNE_set_address (0x00000000000004a2)
-0x000007a2: 03 DW_LNS_advance_line (118)
-0x000007a4: 05 DW_LNS_set_column (16)
-0x000007a6: 06 DW_LNS_negate_stmt
+0x0000079e: 00 DW_LNE_set_address (0x000000000000049b)
+0x000007a5: 03 DW_LNS_advance_line (122)
 0x000007a7: 01 DW_LNS_copy
-            0x00000000000004a2    118     16      1   0             0  is_stmt
+            0x000000000000049b    122     16      1   0             0  is_stmt
 
 
 0x000007a8: 00 DW_LNE_set_address (0x00000000000004af)
-0x000007af: 03 DW_LNS_advance_line (122)
-0x000007b1: 01 DW_LNS_copy
-            0x00000000000004af    122     16      1   0             0  is_stmt
+0x000007af: 03 DW_LNS_advance_line (125)
+0x000007b1: 05 DW_LNS_set_column (22)
+0x000007b3: 01 DW_LNS_copy
+            0x00000000000004af    125     22      1   0             0  is_stmt
 
 
-0x000007b2: 00 DW_LNE_set_address (0x00000000000004c3)
-0x000007b9: 03 DW_LNS_advance_line (125)
-0x000007bb: 05 DW_LNS_set_column (22)
-0x000007bd: 01 DW_LNS_copy
-            0x00000000000004c3    125     22      1   0             0  is_stmt
+0x000007b4: 00 DW_LNE_set_address (0x00000000000004b6)
+0x000007bb: 03 DW_LNS_advance_line (126)
+0x000007bd: 05 DW_LNS_set_column (27)
+0x000007bf: 01 DW_LNS_copy
+            0x00000000000004b6    126     27      1   0             0  is_stmt
 
 
-0x000007be: 00 DW_LNE_set_address (0x00000000000004ca)
-0x000007c5: 03 DW_LNS_advance_line (126)
-0x000007c7: 05 DW_LNS_set_column (27)
-0x000007c9: 01 DW_LNS_copy
-            0x00000000000004ca    126     27      1   0             0  is_stmt
+0x000007c0: 00 DW_LNE_set_address (0x00000000000004bf)
+0x000007c7: 03 DW_LNS_advance_line (127)
+0x000007c9: 05 DW_LNS_set_column (16)
+0x000007cb: 01 DW_LNS_copy
+            0x00000000000004bf    127     16      1   0             0  is_stmt
 
 
-0x000007ca: 00 DW_LNE_set_address (0x00000000000004d3)
-0x000007d1: 03 DW_LNS_advance_line (127)
-0x000007d3: 05 DW_LNS_set_column (16)
-0x000007d5: 01 DW_LNS_copy
-            0x00000000000004d3    127     16      1   0             0  is_stmt
+0x000007cc: 00 DW_LNE_set_address (0x00000000000004c7)
+0x000007d3: 05 DW_LNS_set_column (27)
+0x000007d5: 06 DW_LNS_negate_stmt
+0x000007d6: 01 DW_LNS_copy
+            0x00000000000004c7    127     27      1   0             0 
 
 
-0x000007d6: 00 DW_LNE_set_address (0x00000000000004db)
-0x000007dd: 05 DW_LNS_set_column (27)
-0x000007df: 06 DW_LNS_negate_stmt
+0x000007d7: 00 DW_LNE_set_address (0x00000000000004c9)
+0x000007de: 05 DW_LNS_set_column (35)
 0x000007e0: 01 DW_LNS_copy
-            0x00000000000004db    127     27      1   0             0 
+            0x00000000000004c9    127     35      1   0             0 
 
 
-0x000007e1: 00 DW_LNE_set_address (0x00000000000004dd)
-0x000007e8: 05 DW_LNS_set_column (35)
+0x000007e1: 00 DW_LNE_set_address (0x00000000000004d2)
+0x000007e8: 05 DW_LNS_set_column (27)
 0x000007ea: 01 DW_LNS_copy
-            0x00000000000004dd    127     35      1   0             0 
+            0x00000000000004d2    127     27      1   0             0 
 
 
-0x000007eb: 00 DW_LNE_set_address (0x00000000000004e6)
-0x000007f2: 05 DW_LNS_set_column (27)
+0x000007eb: 00 DW_LNE_set_address (0x00000000000004d7)
+0x000007f2: 05 DW_LNS_set_column (25)
 0x000007f4: 01 DW_LNS_copy
-            0x00000000000004e6    127     27      1   0             0 
+            0x00000000000004d7    127     25      1   0             0 
 
 
-0x000007f5: 00 DW_LNE_set_address (0x00000000000004eb)
-0x000007fc: 05 DW_LNS_set_column (25)
-0x000007fe: 01 DW_LNS_copy
-            0x00000000000004eb    127     25      1   0             0 
+0x000007f5: 00 DW_LNE_set_address (0x00000000000004da)
+0x000007fc: 03 DW_LNS_advance_line (126)
+0x000007fe: 05 DW_LNS_set_column (27)
+0x00000800: 06 DW_LNS_negate_stmt
+0x00000801: 01 DW_LNS_copy
+            0x00000000000004da    126     27      1   0             0  is_stmt
 
 
-0x000007ff: 00 DW_LNE_set_address (0x00000000000004ee)
-0x00000806: 03 DW_LNS_advance_line (126)
-0x00000808: 05 DW_LNS_set_column (27)
-0x0000080a: 06 DW_LNS_negate_stmt
-0x0000080b: 01 DW_LNS_copy
-            0x00000000000004ee    126     27      1   0             0  is_stmt
+0x00000802: 00 DW_LNE_set_address (0x00000000000004df)
+0x00000809: 05 DW_LNS_set_column (13)
+0x0000080b: 06 DW_LNS_negate_stmt
+0x0000080c: 01 DW_LNS_copy
+            0x00000000000004df    126     13      1   0             0 
 
 
-0x0000080c: 00 DW_LNE_set_address (0x00000000000004f3)
-0x00000813: 05 DW_LNS_set_column (13)
-0x00000815: 06 DW_LNS_negate_stmt
-0x00000816: 01 DW_LNS_copy
-            0x00000000000004f3    126     13      1   0             0 
+0x0000080d: 00 DW_LNE_set_address (0x00000000000004e7)
+0x00000814: 03 DW_LNS_advance_line (128)
+0x00000816: 06 DW_LNS_negate_stmt
+0x00000817: 01 DW_LNS_copy
+            0x00000000000004e7    128     13      1   0             0  is_stmt
 
 
-0x00000817: 00 DW_LNE_set_address (0x00000000000004fb)
-0x0000081e: 03 DW_LNS_advance_line (128)
-0x00000820: 06 DW_LNS_negate_stmt
-0x00000821: 01 DW_LNS_copy
-            0x00000000000004fb    128     13      1   0             0  is_stmt
+0x00000818: 00 DW_LNE_set_address (0x00000000000004ef)
+0x0000081f: 05 DW_LNS_set_column (22)
+0x00000821: 06 DW_LNS_negate_stmt
+0x00000822: 01 DW_LNS_copy
+            0x00000000000004ef    128     22      1   0             0 
 
 
-0x00000822: 00 DW_LNE_set_address (0x0000000000000503)
-0x00000829: 05 DW_LNS_set_column (22)
-0x0000082b: 06 DW_LNS_negate_stmt
-0x0000082c: 01 DW_LNS_copy
-            0x0000000000000503    128     22      1   0             0 
+0x00000823: 00 DW_LNE_set_address (0x00000000000004f4)
+0x0000082a: 03 DW_LNS_advance_line (130)
+0x0000082c: 05 DW_LNS_set_column (16)
+0x0000082e: 06 DW_LNS_negate_stmt
+0x0000082f: 01 DW_LNS_copy
+            0x00000000000004f4    130     16      1   0             0  is_stmt
 
 
-0x0000082d: 00 DW_LNE_set_address (0x0000000000000508)
-0x00000834: 03 DW_LNS_advance_line (130)
-0x00000836: 05 DW_LNS_set_column (16)
-0x00000838: 06 DW_LNS_negate_stmt
-0x00000839: 01 DW_LNS_copy
-            0x0000000000000508    130     16      1   0             0  is_stmt
+0x00000830: 00 DW_LNE_set_address (0x00000000000004fc)
+0x00000837: 05 DW_LNS_set_column (14)
+0x00000839: 06 DW_LNS_negate_stmt
+0x0000083a: 01 DW_LNS_copy
+            0x00000000000004fc    130     14      1   0             0 
 
 
-0x0000083a: 00 DW_LNE_set_address (0x0000000000000510)
-0x00000841: 05 DW_LNS_set_column (14)
-0x00000843: 06 DW_LNS_negate_stmt
+0x0000083b: 00 DW_LNE_set_address (0x000000000000050b)
+0x00000842: 05 DW_LNS_set_column (25)
 0x00000844: 01 DW_LNS_copy
-            0x0000000000000510    130     14      1   0             0 
+            0x000000000000050b    130     25      1   0             0 
 
 
-0x00000845: 00 DW_LNE_set_address (0x000000000000051f)
-0x0000084c: 05 DW_LNS_set_column (25)
-0x0000084e: 01 DW_LNS_copy
-            0x000000000000051f    130     25      1   0             0 
+0x00000845: 00 DW_LNE_set_address (0x0000000000000512)
+0x0000084c: 03 DW_LNS_advance_line (133)
+0x0000084e: 05 DW_LNS_set_column (11)
+0x00000850: 06 DW_LNS_negate_stmt
+0x00000851: 01 DW_LNS_copy
+            0x0000000000000512    133     11      1   0             0  is_stmt
 
 
-0x0000084f: 00 DW_LNE_set_address (0x0000000000000526)
-0x00000856: 03 DW_LNS_advance_line (133)
-0x00000858: 05 DW_LNS_set_column (11)
-0x0000085a: 06 DW_LNS_negate_stmt
-0x0000085b: 01 DW_LNS_copy
-            0x0000000000000526    133     11      1   0             0  is_stmt
+0x00000852: 00 DW_LNE_set_address (0x0000000000000517)
+0x00000859: 03 DW_LNS_advance_line (122)
+0x0000085b: 05 DW_LNS_set_column (16)
+0x0000085d: 01 DW_LNS_copy
+            0x0000000000000517    122     16      1   0             0  is_stmt
 
 
-0x0000085c: 00 DW_LNE_set_address (0x000000000000052b)
-0x00000863: 03 DW_LNS_advance_line (122)
-0x00000865: 05 DW_LNS_set_column (16)
-0x00000867: 01 DW_LNS_copy
-            0x000000000000052b    122     16      1   0             0  is_stmt
+0x0000085e: 00 DW_LNE_set_address (0x000000000000051c)
+0x00000865: 05 DW_LNS_set_column (14)
+0x00000867: 06 DW_LNS_negate_stmt
+0x00000868: 01 DW_LNS_copy
+            0x000000000000051c    122     14      1   0             0 
 
 
-0x00000868: 00 DW_LNE_set_address (0x0000000000000530)
-0x0000086f: 05 DW_LNS_set_column (14)
-0x00000871: 06 DW_LNS_negate_stmt
-0x00000872: 01 DW_LNS_copy
-            0x0000000000000530    122     14      1   0             0 
+0x00000869: 00 DW_LNE_set_address (0x0000000000000522)
+0x00000870: 03 DW_LNS_advance_line (110)
+0x00000872: 05 DW_LNS_set_column (11)
+0x00000874: 06 DW_LNS_negate_stmt
+0x00000875: 01 DW_LNS_copy
+            0x0000000000000522    110     11      1   0             0  is_stmt
 
 
-0x00000873: 00 DW_LNE_set_address (0x0000000000000536)
-0x0000087a: 03 DW_LNS_advance_line (110)
-0x0000087c: 05 DW_LNS_set_column (11)
-0x0000087e: 06 DW_LNS_negate_stmt
-0x0000087f: 01 DW_LNS_copy
-            0x0000000000000536    110     11      1   0             0  is_stmt
+0x00000876: 00 DW_LNE_set_address (0x000000000000052a)
+0x0000087d: 03 DW_LNS_advance_line (138)
+0x0000087f: 05 DW_LNS_set_column (4)
+0x00000881: 01 DW_LNS_copy
+            0x000000000000052a    138      4      1   0             0  is_stmt
 
 
-0x00000880: 00 DW_LNE_set_address (0x0000000000000542)
-0x00000887: 03 DW_LNS_advance_line (113)
-0x00000889: 05 DW_LNS_set_column (10)
+0x00000882: 00 DW_LNE_set_address (0x000000000000052e)
+0x00000889: 03 DW_LNS_advance_line (139)
 0x0000088b: 01 DW_LNS_copy
-            0x0000000000000542    113     10      1   0             0  is_stmt
+            0x000000000000052e    139      4      1   0             0  is_stmt
 
 
-0x0000088c: 00 DW_LNE_set_address (0x000000000000054a)
-0x00000893: 03 DW_LNS_advance_line (138)
-0x00000895: 05 DW_LNS_set_column (4)
+0x0000088c: 00 DW_LNE_set_address (0x000000000000053e)
+0x00000893: 03 DW_LNS_advance_line (142)
+0x00000895: 05 DW_LNS_set_column (20)
 0x00000897: 01 DW_LNS_copy
-            0x000000000000054a    138      4      1   0             0  is_stmt
+            0x000000000000053e    142     20      1   0             0  is_stmt
 
 
-0x00000898: 00 DW_LNE_set_address (0x000000000000054e)
-0x0000089f: 03 DW_LNS_advance_line (139)
+0x00000898: 00 DW_LNE_set_address (0x0000000000000546)
+0x0000089f: 03 DW_LNS_advance_line (146)
 0x000008a1: 01 DW_LNS_copy
-            0x000000000000054e    139      4      1   0             0  is_stmt
+            0x0000000000000546    146     20      1   0             0  is_stmt
 
 
-0x000008a2: 00 DW_LNE_set_address (0x000000000000055e)
-0x000008a9: 03 DW_LNS_advance_line (142)
-0x000008ab: 05 DW_LNS_set_column (20)
+0x000008a2: 00 DW_LNE_set_address (0x000000000000054d)
+0x000008a9: 03 DW_LNS_advance_line (147)
+0x000008ab: 05 DW_LNS_set_column (7)
 0x000008ad: 01 DW_LNS_copy
-            0x000000000000055e    142     20      1   0             0  is_stmt
+            0x000000000000054d    147      7      1   0             0  is_stmt
 
 
-0x000008ae: 00 DW_LNE_set_address (0x0000000000000566)
-0x000008b5: 03 DW_LNS_advance_line (146)
-0x000008b7: 01 DW_LNS_copy
-            0x0000000000000566    146     20      1   0             0  is_stmt
+0x000008ae: 00 DW_LNE_set_address (0x0000000000000551)
+0x000008b5: 03 DW_LNS_advance_line (143)
+0x000008b7: 05 DW_LNS_set_column (11)
+0x000008b9: 01 DW_LNS_copy
+            0x0000000000000551    143     11      1   0             0  is_stmt
 
 
-0x000008b8: 00 DW_LNE_set_address (0x000000000000056d)
-0x000008bf: 03 DW_LNS_advance_line (147)
-0x000008c1: 05 DW_LNS_set_column (7)
-0x000008c3: 01 DW_LNS_copy
-            0x000000000000056d    147      7      1   0             0  is_stmt
+0x000008ba: 00 DW_LNE_set_address (0x0000000000000555)
+0x000008c1: 05 DW_LNS_set_column (20)
+0x000008c3: 06 DW_LNS_negate_stmt
+0x000008c4: 01 DW_LNS_copy
+            0x0000000000000555    143     20      1   0             0 
 
 
-0x000008c4: 00 DW_LNE_set_address (0x0000000000000571)
-0x000008cb: 03 DW_LNS_advance_line (143)
-0x000008cd: 05 DW_LNS_set_column (11)
-0x000008cf: 01 DW_LNS_copy
-            0x0000000000000571    143     11      1   0             0  is_stmt
+0x000008c5: 00 DW_LNE_set_address (0x000000000000055a)
+0x000008cc: 05 DW_LNS_set_column (11)
+0x000008ce: 01 DW_LNS_copy
+            0x000000000000055a    143     11      1   0             0 
 
 
-0x000008d0: 00 DW_LNE_set_address (0x0000000000000575)
-0x000008d7: 05 DW_LNS_set_column (20)
-0x000008d9: 06 DW_LNS_negate_stmt
-0x000008da: 01 DW_LNS_copy
-            0x0000000000000575    143     20      1   0             0 
+0x000008cf: 00 DW_LNE_set_address (0x0000000000000561)
+0x000008d6: 03 DW_LNS_advance_line (141)
+0x000008d8: 05 DW_LNS_set_column (4)
+0x000008da: 06 DW_LNS_negate_stmt
+0x000008db: 01 DW_LNS_copy
+            0x0000000000000561    141      4      1   0             0  is_stmt
 
 
-0x000008db: 00 DW_LNE_set_address (0x000000000000057a)
-0x000008e2: 05 DW_LNS_set_column (11)
-0x000008e4: 01 DW_LNS_copy
-            0x000000000000057a    143     11      1   0             0 
+0x000008dc: 00 DW_LNE_set_address (0x0000000000000567)
+0x000008e3: 03 DW_LNS_advance_line (159)
+0x000008e5: 01 DW_LNS_copy
+            0x0000000000000567    159      4      1   0             0  is_stmt
 
 
-0x000008e5: 00 DW_LNE_set_address (0x0000000000000581)
-0x000008ec: 03 DW_LNS_advance_line (141)
-0x000008ee: 05 DW_LNS_set_column (4)
-0x000008f0: 06 DW_LNS_negate_stmt
+0x000008e6: 00 DW_LNE_set_address (0x000000000000057e)
+0x000008ed: 03 DW_LNS_advance_line (161)
+0x000008ef: 05 DW_LNS_set_column (1)
 0x000008f1: 01 DW_LNS_copy
-            0x0000000000000581    141      4      1   0             0  is_stmt
-
-
-0x000008f2: 00 DW_LNE_set_address (0x0000000000000587)
-0x000008f9: 03 DW_LNS_advance_line (159)
-0x000008fb: 01 DW_LNS_copy
-            0x0000000000000587    159      4      1   0             0  is_stmt
-
+            0x000000000000057e    161      1      1   0             0  is_stmt
 
-0x000008fc: 00 DW_LNE_set_address (0x000000000000059e)
-0x00000903: 03 DW_LNS_advance_line (161)
-0x00000905: 05 DW_LNS_set_column (1)
-0x00000907: 01 DW_LNS_copy
-            0x000000000000059e    161      1      1   0             0  is_stmt
 
-
-0x00000908: 00 DW_LNE_set_address (0x00000000000005a8)
-0x0000090f: 00 DW_LNE_end_sequence
-            0x00000000000005a8    161      1      1   0             0  is_stmt end_sequence
+0x000008f2: 00 DW_LNE_set_address (0x0000000000000588)
+0x000008f9: 00 DW_LNE_end_sequence
+            0x0000000000000588    161      1      1   0             0  is_stmt end_sequence
 
 
 .debug_str contents:
@@ -4470,11 +4457,11 @@ file_names[  4]:
 00000000 000002f2 00000330
 00000000 0000035a 00000363
 00000000 <End of list>
-00000028 000004c3 00000508
+00000028 000004af 000004f4
 00000028 00000000 00000001
 00000028 <End of list>
 00000040 00000006 00000377
-00000040 00000379 000005a8
+00000040 00000379 00000588
 00000040 <End of list>
 (module
  (type $0 (func (param i32) (result i32)))
@@ -5684,7 +5671,7 @@ file_names[  4]:
     )
    )
   )
-  ;; code offset: 0x391 - 0x59e
+  ;; code offset: 0x391 - 0x57e
   (block $block1
    ;; code offset: 0x393 - 0x3b8
    (block $block
@@ -5849,553 +5836,511 @@ file_names[  4]:
      (local.get $2)
     )
    )
-   ;; code offset: 0x410 - 0x54a
-   (block $block4
-    ;; code offset: 0x412 - 0x53e
-    (block $block3
-     ;; code offset: 0x414 - 0x44f
-     (block $block2
-      ;; code offset: 0x41b - 0x444
-      (if
-       ;; code offset: 0x41a - 0x41b
-       (i32.gt_s
+   ;; code offset: 0x410 - 0x52a
+   (block $block3
+    ;; code offset: 0x412 - 0x43b
+    (block $block2
+     ;; code offset: 0x414 - 0x430
+     (loop $label1
+      ;; code offset: 0x420 - 0x423
+      (i32.store
+       ;; code offset: 0x41d - 0x41e
+       (i32.add
         ;; code offset: 0x416 - 0x418
-        (local.get $3)
-        ;; code offset: 0x418 - 0x41a
-        (i32.const 0)
+        (local.get $1)
+        ;; code offset: 0x41c - 0x41d
+        (i32.shl
+         ;; code offset: 0x418 - 0x41a
+         (local.get $0)
+         ;; code offset: 0x41a - 0x41c
+         (i32.const 2)
+        )
        )
-       (then
-        ;; code offset: 0x41d - 0x439
-        (loop $label1
-         ;; code offset: 0x429 - 0x42c
-         (i32.store
-          ;; code offset: 0x426 - 0x427
-          (i32.add
-           ;; code offset: 0x41f - 0x421
-           (local.get $1)
-           ;; code offset: 0x425 - 0x426
-           (i32.shl
-            ;; code offset: 0x421 - 0x423
-            (local.get $0)
-            ;; code offset: 0x423 - 0x425
-            (i32.const 2)
-           )
-          )
-          ;; code offset: 0x427 - 0x429
+       ;; code offset: 0x41e - 0x420
+       (local.get $0)
+      )
+      ;; code offset: 0x42d - 0x42f
+      (br_if $label1
+       ;; code offset: 0x42c - 0x42d
+       (i32.ne
+        ;; code offset: 0x428 - 0x42a
+        (local.tee $0
+         ;; code offset: 0x427 - 0x428
+         (i32.add
+          ;; code offset: 0x423 - 0x425
           (local.get $0)
+          ;; code offset: 0x425 - 0x427
+          (i32.const 1)
          )
-         ;; code offset: 0x436 - 0x438
-         (br_if $label1
-          ;; code offset: 0x435 - 0x436
-          (i32.ne
-           ;; code offset: 0x431 - 0x433
-           (local.tee $0
-            ;; code offset: 0x430 - 0x431
-            (i32.add
-             ;; code offset: 0x42c - 0x42e
-             (local.get $0)
-             ;; code offset: 0x42e - 0x430
-             (i32.const 1)
-            )
-           )
-           ;; code offset: 0x433 - 0x435
-           (local.get $3)
-          )
-         )
-        )
-        ;; code offset: 0x43b - 0x43d
-        (local.set $6
-         ;; code offset: 0x439 - 0x43b
-         (i32.const 30)
-        )
-        ;; code offset: 0x43f - 0x441
-        (local.set $2
-         ;; code offset: 0x43d - 0x43f
-         (local.get $3)
         )
-        ;; code offset: 0x441 - 0x443
-        (br $block2)
+        ;; code offset: 0x42a - 0x42c
+        (local.get $3)
        )
       )
-      ;; code offset: 0x446 - 0x448
-      (local.set $6
-       ;; code offset: 0x444 - 0x446
-       (i32.const 30)
-      )
-      ;; code offset: 0x44a - 0x44c
-      (local.set $2
-       ;; code offset: 0x448 - 0x44a
-       (local.get $3)
-      )
-      ;; code offset: 0x44c - 0x44e
-      (br $block3)
      )
-     ;; code offset: 0x44f - 0x53b
-     (loop $label6
-      ;; code offset: 0x453 - 0x455
-      (local.set $0
-       ;; code offset: 0x451 - 0x453
-       (i32.const 0)
-      )
-      ;; code offset: 0x455 - 0x482
-      (loop $label2
-       ;; code offset: 0x467 - 0x46a
-       (i32.store offset=16
-        ;; code offset: 0x457 - 0x459
-        (local.get $8)
-        ;; code offset: 0x466 - 0x467
-        (i32.add
-         ;; code offset: 0x461 - 0x464
-         (i32.load
-          ;; code offset: 0x460 - 0x461
-          (i32.add
-           ;; code offset: 0x459 - 0x45b
-           (local.get $1)
-           ;; code offset: 0x45f - 0x460
-           (i32.shl
-            ;; code offset: 0x45b - 0x45d
-            (local.get $0)
-            ;; code offset: 0x45d - 0x45f
-            (i32.const 2)
-           )
-          )
-         )
-         ;; code offset: 0x464 - 0x466
-         (i32.const 1)
-        )
-       )
-       ;; code offset: 0x474 - 0x475
-       (drop
-        ;; code offset: 0x472 - 0x474
-        (call $iprintf
-         ;; code offset: 0x46a - 0x46d
-         (i32.const 1047)
-         ;; code offset: 0x471 - 0x472
+     ;; code offset: 0x432 - 0x434
+     (local.set $6
+      ;; code offset: 0x430 - 0x432
+      (i32.const 30)
+     )
+     ;; code offset: 0x436 - 0x438
+     (local.set $2
+      ;; code offset: 0x434 - 0x436
+      (local.get $3)
+     )
+     ;; code offset: 0x438 - 0x43a
+     (br $block2)
+    )
+    ;; code offset: 0x43b - 0x527
+    (loop $label6
+     ;; code offset: 0x43f - 0x441
+     (local.set $0
+      ;; code offset: 0x43d - 0x43f
+      (i32.const 0)
+     )
+     ;; code offset: 0x441 - 0x46e
+     (loop $label2
+      ;; code offset: 0x453 - 0x456
+      (i32.store offset=16
+       ;; code offset: 0x443 - 0x445
+       (local.get $8)
+       ;; code offset: 0x452 - 0x453
+       (i32.add
+        ;; code offset: 0x44d - 0x450
+        (i32.load
+         ;; code offset: 0x44c - 0x44d
          (i32.add
-          ;; code offset: 0x46d - 0x46f
-          (local.get $8)
-          ;; code offset: 0x46f - 0x471
-          (i32.const 16)
-         )
-        )
-       )
-       ;; code offset: 0x47f - 0x481
-       (br_if $label2
-        ;; code offset: 0x47e - 0x47f
-        (i32.ne
-         ;; code offset: 0x47a - 0x47c
-         (local.tee $0
-          ;; code offset: 0x479 - 0x47a
-          (i32.add
-           ;; code offset: 0x475 - 0x477
+          ;; code offset: 0x445 - 0x447
+          (local.get $1)
+          ;; code offset: 0x44b - 0x44c
+          (i32.shl
+           ;; code offset: 0x447 - 0x449
            (local.get $0)
-           ;; code offset: 0x477 - 0x479
-           (i32.const 1)
+           ;; code offset: 0x449 - 0x44b
+           (i32.const 2)
           )
          )
-         ;; code offset: 0x47c - 0x47e
-         (local.get $3)
         )
+        ;; code offset: 0x450 - 0x452
+        (i32.const 1)
        )
       )
-      ;; code offset: 0x486 - 0x487
+      ;; code offset: 0x460 - 0x461
       (drop
-       ;; code offset: 0x484 - 0x486
-       (call $putchar
-        ;; code offset: 0x482 - 0x484
-        (i32.const 10)
+       ;; code offset: 0x45e - 0x460
+       (call $iprintf
+        ;; code offset: 0x456 - 0x459
+        (i32.const 1047)
+        ;; code offset: 0x45d - 0x45e
+        (i32.add
+         ;; code offset: 0x459 - 0x45b
+         (local.get $8)
+         ;; code offset: 0x45b - 0x45d
+         (i32.const 16)
+        )
        )
       )
-      ;; code offset: 0x48c - 0x4af
-      (if
-       ;; code offset: 0x48b - 0x48c
-       (i32.gt_s
-        ;; code offset: 0x487 - 0x489
-        (local.get $2)
-        ;; code offset: 0x489 - 0x48b
-        (i32.const 1)
+      ;; code offset: 0x46b - 0x46d
+      (br_if $label2
+       ;; code offset: 0x46a - 0x46b
+       (i32.ne
+        ;; code offset: 0x466 - 0x468
+        (local.tee $0
+         ;; code offset: 0x465 - 0x466
+         (i32.add
+          ;; code offset: 0x461 - 0x463
+          (local.get $0)
+          ;; code offset: 0x463 - 0x465
+          (i32.const 1)
+         )
+        )
+        ;; code offset: 0x468 - 0x46a
+        (local.get $3)
        )
-       (then
-        ;; code offset: 0x48e - 0x4ae
-        (loop $label3
-         ;; code offset: 0x49f - 0x4a2
-         (i32.store
-          ;; code offset: 0x49c - 0x49d
-          (i32.add
-           ;; code offset: 0x490 - 0x492
-           (local.get $5)
-           ;; code offset: 0x49b - 0x49c
-           (i32.shl
-            ;; code offset: 0x497 - 0x499
-            (local.tee $0
-             ;; code offset: 0x496 - 0x497
-             (i32.sub
-              ;; code offset: 0x492 - 0x494
-              (local.get $2)
-              ;; code offset: 0x494 - 0x496
-              (i32.const 1)
-             )
+      )
+     )
+     ;; code offset: 0x472 - 0x473
+     (drop
+      ;; code offset: 0x470 - 0x472
+      (call $putchar
+       ;; code offset: 0x46e - 0x470
+       (i32.const 10)
+      )
+     )
+     ;; code offset: 0x478 - 0x49b
+     (if
+      ;; code offset: 0x477 - 0x478
+      (i32.gt_s
+       ;; code offset: 0x473 - 0x475
+       (local.get $2)
+       ;; code offset: 0x475 - 0x477
+       (i32.const 1)
+      )
+      (then
+       ;; code offset: 0x47a - 0x49a
+       (loop $label3
+        ;; code offset: 0x48b - 0x48e
+        (i32.store
+         ;; code offset: 0x488 - 0x489
+         (i32.add
+          ;; code offset: 0x47c - 0x47e
+          (local.get $5)
+          ;; code offset: 0x487 - 0x488
+          (i32.shl
+           ;; code offset: 0x483 - 0x485
+           (local.tee $0
+            ;; code offset: 0x482 - 0x483
+            (i32.sub
+             ;; code offset: 0x47e - 0x480
+             (local.get $2)
+             ;; code offset: 0x480 - 0x482
+             (i32.const 1)
             )
-            ;; code offset: 0x499 - 0x49b
-            (i32.const 2)
            )
+           ;; code offset: 0x485 - 0x487
+           (i32.const 2)
           )
-          ;; code offset: 0x49d - 0x49f
-          (local.get $2)
          )
-         ;; code offset: 0x4ab - 0x4ad
-         (br_if $label3
-          (block (result i32)
-           (local.set $scratch
-            ;; code offset: 0x4a6 - 0x4a7
-            (i32.gt_s
-             ;; code offset: 0x4a2 - 0x4a4
-             (local.get $2)
-             ;; code offset: 0x4a4 - 0x4a6
-             (i32.const 2)
-            )
-           )
-           ;; code offset: 0x4a9 - 0x4ab
-           (local.set $2
-            ;; code offset: 0x4a7 - 0x4a9
-            (local.get $0)
+         ;; code offset: 0x489 - 0x48b
+         (local.get $2)
+        )
+        ;; code offset: 0x497 - 0x499
+        (br_if $label3
+         (block (result i32)
+          (local.set $scratch
+           ;; code offset: 0x492 - 0x493
+           (i32.gt_s
+            ;; code offset: 0x48e - 0x490
+            (local.get $2)
+            ;; code offset: 0x490 - 0x492
+            (i32.const 2)
            )
-           (local.get $scratch)
           )
+          ;; code offset: 0x495 - 0x497
+          (local.set $2
+           ;; code offset: 0x493 - 0x495
+           (local.get $0)
+          )
+          (local.get $scratch)
          )
         )
        )
       )
+     )
+     ;; code offset: 0x4a0 - 0x4a2
+     (br_if $block3
+      ;; code offset: 0x49f - 0x4a0
+      (i32.eq
+       ;; code offset: 0x49b - 0x49d
+       (local.get $2)
+       ;; code offset: 0x49d - 0x49f
+       (local.get $3)
+      )
+     )
+     ;; code offset: 0x4a7 - 0x4a9
+     (local.set $6
+      ;; code offset: 0x4a6 - 0x4a7
+      (i32.sub
+       ;; code offset: 0x4a2 - 0x4a4
+       (local.get $6)
+       ;; code offset: 0x4a4 - 0x4a6
+       (i32.const 1)
+      )
+     )
+     ;; code offset: 0x4a9 - 0x522
+     (loop $label5
+      ;; code offset: 0x4ad - 0x4af
+      (local.set $0
+       ;; code offset: 0x4ab - 0x4ad
+       (i32.const 0)
+      )
       ;; code offset: 0x4b4 - 0x4b6
-      (br_if $block4
-       ;; code offset: 0x4b3 - 0x4b4
-       (i32.eq
+      (local.set $7
+       ;; code offset: 0x4b1 - 0x4b4
+       (i32.load
         ;; code offset: 0x4af - 0x4b1
-        (local.get $2)
-        ;; code offset: 0x4b1 - 0x4b3
-        (local.get $3)
+        (local.get $1)
        )
       )
-      ;; code offset: 0x4bb - 0x4bd
-      (local.set $6
+      ;; code offset: 0x4bb - 0x4e7
+      (if
        ;; code offset: 0x4ba - 0x4bb
-       (i32.sub
+       (i32.gt_s
         ;; code offset: 0x4b6 - 0x4b8
-        (local.get $6)
+        (local.get $2)
         ;; code offset: 0x4b8 - 0x4ba
-        (i32.const 1)
-       )
-      )
-      ;; code offset: 0x4bd - 0x536
-      (loop $label5
-       ;; code offset: 0x4c1 - 0x4c3
-       (local.set $0
-        ;; code offset: 0x4bf - 0x4c1
         (i32.const 0)
        )
-       ;; code offset: 0x4c8 - 0x4ca
-       (local.set $7
-        ;; code offset: 0x4c5 - 0x4c8
-        (i32.load
-         ;; code offset: 0x4c3 - 0x4c5
-         (local.get $1)
-        )
-       )
-       ;; code offset: 0x4cf - 0x4fb
-       (if
-        ;; code offset: 0x4ce - 0x4cf
-        (i32.gt_s
-         ;; code offset: 0x4ca - 0x4cc
-         (local.get $2)
-         ;; code offset: 0x4cc - 0x4ce
-         (i32.const 0)
-        )
-        (then
-         ;; code offset: 0x4d1 - 0x4f6
-         (loop $label4
-          ;; code offset: 0x4eb - 0x4ee
-          (i32.store
-           ;; code offset: 0x4da - 0x4db
+       (then
+        ;; code offset: 0x4bd - 0x4e2
+        (loop $label4
+         ;; code offset: 0x4d7 - 0x4da
+         (i32.store
+          ;; code offset: 0x4c6 - 0x4c7
+          (i32.add
+           ;; code offset: 0x4bf - 0x4c1
+           (local.get $1)
+           ;; code offset: 0x4c5 - 0x4c6
+           (i32.shl
+            ;; code offset: 0x4c1 - 0x4c3
+            (local.get $0)
+            ;; code offset: 0x4c3 - 0x4c5
+            (i32.const 2)
+           )
+          )
+          ;; code offset: 0x4d4 - 0x4d7
+          (i32.load
+           ;; code offset: 0x4d3 - 0x4d4
            (i32.add
-            ;; code offset: 0x4d3 - 0x4d5
+            ;; code offset: 0x4c7 - 0x4c9
             (local.get $1)
-            ;; code offset: 0x4d9 - 0x4da
+            ;; code offset: 0x4d2 - 0x4d3
             (i32.shl
-             ;; code offset: 0x4d5 - 0x4d7
-             (local.get $0)
-             ;; code offset: 0x4d7 - 0x4d9
-             (i32.const 2)
-            )
-           )
-           ;; code offset: 0x4e8 - 0x4eb
-           (i32.load
-            ;; code offset: 0x4e7 - 0x4e8
-            (i32.add
-             ;; code offset: 0x4db - 0x4dd
-             (local.get $1)
-             ;; code offset: 0x4e6 - 0x4e7
-             (i32.shl
-              ;; code offset: 0x4e2 - 0x4e4
-              (local.tee $0
-               ;; code offset: 0x4e1 - 0x4e2
-               (i32.add
-                ;; code offset: 0x4dd - 0x4df
-                (local.get $0)
-                ;; code offset: 0x4df - 0x4e1
-                (i32.const 1)
-               )
+             ;; code offset: 0x4ce - 0x4d0
+             (local.tee $0
+              ;; code offset: 0x4cd - 0x4ce
+              (i32.add
+               ;; code offset: 0x4c9 - 0x4cb
+               (local.get $0)
+               ;; code offset: 0x4cb - 0x4cd
+               (i32.const 1)
               )
-              ;; code offset: 0x4e4 - 0x4e6
-              (i32.const 2)
              )
+             ;; code offset: 0x4d0 - 0x4d2
+             (i32.const 2)
             )
            )
           )
-          ;; code offset: 0x4f3 - 0x4f5
-          (br_if $label4
-           ;; code offset: 0x4f2 - 0x4f3
-           (i32.ne
-            ;; code offset: 0x4ee - 0x4f0
-            (local.get $0)
-            ;; code offset: 0x4f0 - 0x4f2
-            (local.get $2)
-           )
-          )
          )
-         ;; code offset: 0x4f8 - 0x4fa
-         (local.set $0
-          ;; code offset: 0x4f6 - 0x4f8
-          (local.get $2)
+         ;; code offset: 0x4df - 0x4e1
+         (br_if $label4
+          ;; code offset: 0x4de - 0x4df
+          (i32.ne
+           ;; code offset: 0x4da - 0x4dc
+           (local.get $0)
+           ;; code offset: 0x4dc - 0x4de
+           (local.get $2)
+          )
          )
         )
+        ;; code offset: 0x4e4 - 0x4e6
+        (local.set $0
+         ;; code offset: 0x4e2 - 0x4e4
+         (local.get $2)
+        )
        )
-       ;; code offset: 0x505 - 0x508
-       (i32.store
-        ;; code offset: 0x502 - 0x503
+      )
+      ;; code offset: 0x4f1 - 0x4f4
+      (i32.store
+       ;; code offset: 0x4ee - 0x4ef
+       (i32.add
+        ;; code offset: 0x4e7 - 0x4e9
+        (local.get $1)
+        ;; code offset: 0x4ed - 0x4ee
+        (i32.shl
+         ;; code offset: 0x4e9 - 0x4eb
+         (local.get $0)
+         ;; code offset: 0x4eb - 0x4ed
+         (i32.const 2)
+        )
+       )
+       ;; code offset: 0x4ef - 0x4f1
+       (local.get $7)
+      )
+      ;; code offset: 0x508 - 0x50b
+      (i32.store
+       ;; code offset: 0x4fc - 0x4fe
+       (local.tee $0
+        ;; code offset: 0x4fb - 0x4fc
         (i32.add
-         ;; code offset: 0x4fb - 0x4fd
-         (local.get $1)
-         ;; code offset: 0x501 - 0x502
+         ;; code offset: 0x4f4 - 0x4f6
+         (local.get $5)
+         ;; code offset: 0x4fa - 0x4fb
          (i32.shl
-          ;; code offset: 0x4fd - 0x4ff
-          (local.get $0)
-          ;; code offset: 0x4ff - 0x501
+          ;; code offset: 0x4f6 - 0x4f8
+          (local.get $2)
+          ;; code offset: 0x4f8 - 0x4fa
           (i32.const 2)
          )
         )
-        ;; code offset: 0x503 - 0x505
-        (local.get $7)
        )
-       ;; code offset: 0x51c - 0x51f
-       (i32.store
-        ;; code offset: 0x510 - 0x512
+       ;; code offset: 0x507 - 0x508
+       (i32.sub
+        ;; code offset: 0x503 - 0x505
         (local.tee $0
-         ;; code offset: 0x50f - 0x510
-         (i32.add
-          ;; code offset: 0x508 - 0x50a
-          (local.get $5)
-          ;; code offset: 0x50e - 0x50f
-          (i32.shl
-           ;; code offset: 0x50a - 0x50c
-           (local.get $2)
-           ;; code offset: 0x50c - 0x50e
-           (i32.const 2)
-          )
-         )
-        )
-        ;; code offset: 0x51b - 0x51c
-        (i32.sub
-         ;; code offset: 0x517 - 0x519
-         (local.tee $0
-          ;; code offset: 0x514 - 0x517
-          (i32.load
-           ;; code offset: 0x512 - 0x514
-           (local.get $0)
-          )
+         ;; code offset: 0x500 - 0x503
+         (i32.load
+          ;; code offset: 0x4fe - 0x500
+          (local.get $0)
          )
-         ;; code offset: 0x519 - 0x51b
-         (i32.const 1)
         )
+        ;; code offset: 0x505 - 0x507
+        (i32.const 1)
        )
-       ;; code offset: 0x524 - 0x535
-       (if
-        ;; code offset: 0x523 - 0x524
-        (i32.le_s
-         ;; code offset: 0x51f - 0x521
-         (local.get $0)
-         ;; code offset: 0x521 - 0x523
-         (i32.const 1)
-        )
-        (then
-         ;; code offset: 0x530 - 0x532
-         (br_if $label5
-          ;; code offset: 0x52f - 0x530
-          (i32.ne
-           ;; code offset: 0x52b - 0x52d
-           (local.tee $2
-            ;; code offset: 0x52a - 0x52b
-            (i32.add
-             ;; code offset: 0x526 - 0x528
-             (local.get $2)
-             ;; code offset: 0x528 - 0x52a
-             (i32.const 1)
-            )
+      )
+      ;; code offset: 0x510 - 0x521
+      (if
+       ;; code offset: 0x50f - 0x510
+       (i32.le_s
+        ;; code offset: 0x50b - 0x50d
+        (local.get $0)
+        ;; code offset: 0x50d - 0x50f
+        (i32.const 1)
+       )
+       (then
+        ;; code offset: 0x51c - 0x51e
+        (br_if $label5
+         ;; code offset: 0x51b - 0x51c
+         (i32.ne
+          ;; code offset: 0x517 - 0x519
+          (local.tee $2
+           ;; code offset: 0x516 - 0x517
+           (i32.add
+            ;; code offset: 0x512 - 0x514
+            (local.get $2)
+            ;; code offset: 0x514 - 0x516
+            (i32.const 1)
            )
-           ;; code offset: 0x52d - 0x52f
-           (local.get $3)
           )
+          ;; code offset: 0x519 - 0x51b
+          (local.get $3)
          )
-         ;; code offset: 0x532 - 0x534
-         (br $block4)
         )
+        ;; code offset: 0x51e - 0x520
+        (br $block3)
        )
       )
-      ;; code offset: 0x538 - 0x53a
-      (br_if $label6
-       ;; code offset: 0x536 - 0x538
-       (local.get $6)
-      )
      )
-     ;; code offset: 0x53b - 0x53d
-     (br $block4)
-    )
-    ;; code offset: 0x53e - 0x548
-    (loop
-     ;; code offset: 0x544 - 0x545
-     (drop
-      ;; code offset: 0x542 - 0x544
-      (call $putchar
-       ;; code offset: 0x540 - 0x542
-       (i32.const 10)
-      )
+     ;; code offset: 0x524 - 0x526
+     (br_if $label6
+      ;; code offset: 0x522 - 0x524
+      (local.get $6)
      )
-     ;; code offset: 0x545 - 0x547
-     (br $block4)
     )
-    ;; code offset: 0x548 - 0x549
-    (unreachable)
+    ;; code offset: 0x527 - 0x529
+    (br $block3)
    )
-   ;; code offset: 0x54c - 0x54e
+   ;; code offset: 0x52c - 0x52e
    (call $free
-    ;; code offset: 0x54a - 0x54c
+    ;; code offset: 0x52a - 0x52c
     (local.get $1)
    )
-   ;; code offset: 0x550 - 0x552
+   ;; code offset: 0x530 - 0x532
    (call $free
-    ;; code offset: 0x54e - 0x550
+    ;; code offset: 0x52e - 0x530
     (local.get $5)
    )
-   ;; code offset: 0x554 - 0x556
+   ;; code offset: 0x534 - 0x536
    (local.set $5
-    ;; code offset: 0x552 - 0x554
+    ;; code offset: 0x532 - 0x534
     (i32.const 0)
    )
-   ;; code offset: 0x558 - 0x55a
+   ;; code offset: 0x538 - 0x53a
    (local.set $0
-    ;; code offset: 0x556 - 0x558
+    ;; code offset: 0x536 - 0x538
     (i32.const 0)
    )
-   ;; code offset: 0x55c - 0x587
+   ;; code offset: 0x53c - 0x567
    (if
-    ;; code offset: 0x55a - 0x55c
+    ;; code offset: 0x53a - 0x53c
     (local.get $4)
     (then
-     ;; code offset: 0x55e - 0x586
+     ;; code offset: 0x53e - 0x566
      (loop $label7
-      ;; code offset: 0x564 - 0x566
+      ;; code offset: 0x544 - 0x546
       (local.set $1
-       ;; code offset: 0x562 - 0x564
+       ;; code offset: 0x542 - 0x544
        (call $"fannkuch_worker(void*)"
-        ;; code offset: 0x560 - 0x562
+        ;; code offset: 0x540 - 0x542
         (local.get $4)
        )
       )
-      ;; code offset: 0x56b - 0x56d
+      ;; code offset: 0x54b - 0x54d
       (local.set $2
-       ;; code offset: 0x568 - 0x56b
+       ;; code offset: 0x548 - 0x54b
        (i32.load offset=8
-        ;; code offset: 0x566 - 0x568
+        ;; code offset: 0x546 - 0x548
         (local.get $4)
        )
       )
-      ;; code offset: 0x56f - 0x571
+      ;; code offset: 0x54f - 0x551
       (call $free
-       ;; code offset: 0x56d - 0x56f
+       ;; code offset: 0x54d - 0x54f
        (local.get $4)
       )
-      ;; code offset: 0x57b - 0x57d
+      ;; code offset: 0x55b - 0x55d
       (local.set $0
-       ;; code offset: 0x57a - 0x57b
+       ;; code offset: 0x55a - 0x55b
        (select
-        ;; code offset: 0x571 - 0x573
+        ;; code offset: 0x551 - 0x553
         (local.get $1)
-        ;; code offset: 0x573 - 0x575
+        ;; code offset: 0x553 - 0x555
         (local.get $0)
-        ;; code offset: 0x579 - 0x57a
+        ;; code offset: 0x559 - 0x55a
         (i32.lt_s
-         ;; code offset: 0x575 - 0x577
+         ;; code offset: 0x555 - 0x557
          (local.get $0)
-         ;; code offset: 0x577 - 0x579
+         ;; code offset: 0x557 - 0x559
          (local.get $1)
         )
        )
       )
-      ;; code offset: 0x57f - 0x581
+      ;; code offset: 0x55f - 0x561
       (local.set $4
-       ;; code offset: 0x57d - 0x57f
+       ;; code offset: 0x55d - 0x55f
        (local.get $2)
       )
-      ;; code offset: 0x583 - 0x585
+      ;; code offset: 0x563 - 0x565
       (br_if $label7
-       ;; code offset: 0x581 - 0x583
+       ;; code offset: 0x561 - 0x563
        (local.get $2)
       )
      )
     )
    )
-   ;; code offset: 0x58b - 0x58e
+   ;; code offset: 0x56b - 0x56e
    (i32.store offset=4
-    ;; code offset: 0x587 - 0x589
+    ;; code offset: 0x567 - 0x569
     (local.get $8)
-    ;; code offset: 0x589 - 0x58b
+    ;; code offset: 0x569 - 0x56b
     (local.get $0)
    )
-   ;; code offset: 0x592 - 0x595
+   ;; code offset: 0x572 - 0x575
    (i32.store
-    ;; code offset: 0x58e - 0x590
+    ;; code offset: 0x56e - 0x570
     (local.get $8)
-    ;; code offset: 0x590 - 0x592
+    ;; code offset: 0x570 - 0x572
     (local.get $3)
    )
-   ;; code offset: 0x59c - 0x59d
+   ;; code offset: 0x57c - 0x57d
    (drop
-    ;; code offset: 0x59a - 0x59c
+    ;; code offset: 0x57a - 0x57c
     (call $iprintf
-     ;; code offset: 0x595 - 0x598
+     ;; code offset: 0x575 - 0x578
      (i32.const 1024)
-     ;; code offset: 0x598 - 0x59a
+     ;; code offset: 0x578 - 0x57a
      (local.get $8)
     )
    )
   )
-  ;; code offset: 0x5a3 - 0x5a5
+  ;; code offset: 0x583 - 0x585
   (global.set $global$0
-   ;; code offset: 0x5a2 - 0x5a3
+   ;; code offset: 0x582 - 0x583
    (i32.add
-    ;; code offset: 0x59e - 0x5a0
+    ;; code offset: 0x57e - 0x580
     (local.get $8)
-    ;; code offset: 0x5a0 - 0x5a2
+    ;; code offset: 0x580 - 0x582
     (i32.const 32)
    )
   )
-  ;; code offset: 0x5a5 - 0x5a7
+  ;; code offset: 0x585 - 0x587
   (local.get $5)
  )
  ;; custom section ".debug_info", size 851
  ;; custom section ".debug_loc", size 1073
  ;; custom section ".debug_ranges", size 88
  ;; custom section ".debug_abbrev", size 333
- ;; custom section ".debug_line", size 2322
+ ;; custom section ".debug_line", size 2300
  ;; custom section ".debug_str", size 434
  ;; custom section "producers", size 135
 )
diff --git a/test/passes/simplify-locals_all-features_disable-exception-handling.txt b/test/passes/simplify-locals_all-features_disable-exception-handling_disable-stack-switching.txt
similarity index 100%
rename from test/passes/simplify-locals_all-features_disable-exception-handling.txt
rename to test/passes/simplify-locals_all-features_disable-exception-handling_disable-stack-switching.txt
diff --git a/test/passes/simplify-locals_all-features_disable-exception-handling.wast b/test/passes/simplify-locals_all-features_disable-exception-handling_disable-stack-switching.wast
similarity index 100%
rename from test/passes/simplify-locals_all-features_disable-exception-handling.wast
rename to test/passes/simplify-locals_all-features_disable-exception-handling_disable-stack-switching.wast
diff --git a/test/passes/translate-to-fuzz_all-features_metrics_noprint.txt b/test/passes/translate-to-fuzz_all-features_metrics_noprint.txt
index 0cf4bd8d511..79bac424b20 100644
--- a/test/passes/translate-to-fuzz_all-features_metrics_noprint.txt
+++ b/test/passes/translate-to-fuzz_all-features_metrics_noprint.txt
@@ -1,93 +1,92 @@
 Metrics
 total
- [exports]      : 145     
- [funcs]        : 269     
- [globals]      : 6       
- [imports]      : 13      
+ [exports]      : 41      
+ [funcs]        : 114     
+ [globals]      : 13      
+ [imports]      : 12      
  [memories]     : 1       
  [memory-data]  : 31      
- [table-data]   : 80      
+ [table-data]   : 33      
  [tables]       : 2       
  [tags]         : 2       
- [total]        : 93143   
- [vars]         : 4351    
- ArrayCmpxchg   : 15      
- ArrayCopy      : 34      
- ArrayFill      : 27      
- ArrayGet       : 343     
- ArrayLen       : 468     
- ArrayNew       : 1077    
- ArrayNewFixed  : 550     
- ArrayRMW       : 9       
- ArraySet       : 54      
- AtomicCmpxchg  : 50      
- AtomicFence    : 60      
- AtomicNotify   : 30      
- AtomicRMW      : 29      
- Binary         : 3798    
- Block          : 7102    
- BrOn           : 288     
- Break          : 1081    
- Call           : 1292    
- CallIndirect   : 215     
- CallRef        : 266     
- Const          : 14626   
- ContBind       : 1       
- ContNew        : 68      
- DataDrop       : 10      
- Drop           : 592     
- GlobalGet      : 4826    
- GlobalSet      : 2370    
- I31Get         : 72      
- If             : 2596    
- Load           : 344     
- LocalGet       : 8687    
- LocalSet       : 3915    
- Loop           : 911     
+ [total]        : 89280   
+ [vars]         : 3822    
+ ArrayCmpxchg   : 14      
+ ArrayCopy      : 35      
+ ArrayFill      : 24      
+ ArrayGet       : 332     
+ ArrayLen       : 485     
+ ArrayNew       : 1170    
+ ArrayNewFixed  : 259     
+ ArrayRMW       : 19      
+ ArraySet       : 67      
+ AtomicCmpxchg  : 21      
+ AtomicFence    : 55      
+ AtomicNotify   : 20      
+ AtomicRMW      : 31      
+ Binary         : 3205    
+ Block          : 5335    
+ BrOn           : 206     
+ Break          : 820     
+ Call           : 831     
+ CallIndirect   : 72      
+ CallRef        : 221     
+ Const          : 11991   
+ ContNew        : 59      
+ DataDrop       : 14      
+ Drop           : 432     
+ GlobalGet      : 4707    
+ GlobalSet      : 1594    
+ I31Get         : 42      
+ If             : 2005    
+ Load           : 260     
+ LocalGet       : 10609   
+ LocalSet       : 3430    
+ Loop           : 678     
  MemoryCopy     : 13      
- MemoryFill     : 18      
- MemoryInit     : 23      
- Nop            : 795     
- RefAs          : 7167    
- RefCast        : 793     
- RefEq          : 280     
- RefFunc        : 1614    
- RefGetDesc     : 83      
- RefI31         : 707     
- RefIsNull      : 72      
- RefNull        : 8468    
- RefTest        : 80      
- Return         : 464     
- SIMDExtract    : 157     
+ MemoryFill     : 23      
+ MemoryInit     : 13      
+ Nop            : 549     
+ Pop            : 251     
+ RefAs          : 8721    
+ RefCast        : 506     
+ RefEq          : 209     
+ RefFunc        : 1855    
+ RefGetDesc     : 43      
+ RefI31         : 549     
+ RefIsNull      : 65      
+ RefNull        : 10369   
+ RefTest        : 45      
+ Return         : 334     
+ SIMDExtract    : 123     
  SIMDLoad       : 2       
  SIMDReplace    : 1       
- SIMDShift      : 2       
- SIMDShuffle    : 6       
+ SIMDShuffle    : 3       
  SIMDTernary    : 3       
- Select         : 348     
- Store          : 159     
- StringConst    : 523     
- StringEncode   : 62      
- StringEq       : 70      
- StringMeasure  : 82      
- StringNew      : 7       
+ Select         : 251     
+ Store          : 122     
+ StringConst    : 316     
+ StringEncode   : 51      
+ StringEq       : 56      
+ StringMeasure  : 51      
+ StringNew      : 6       
  StringSliceWTF : 2       
- StringWTF16Get : 68      
- StructCmpxchg  : 67      
- StructGet      : 560     
- StructNew      : 9434    
- StructRMW      : 52      
- StructSet      : 78      
- Switch         : 6       
- TableGet       : 2       
- TableSet       : 77      
- Throw          : 58      
- ThrowRef       : 4       
- Try            : 430     
- TryTable       : 440     
- TupleExtract   : 294     
- TupleMake      : 259     
- Unary          : 2249    
- Unreachable    : 1209    
- WideIntAddSub  : 26      
- WideIntMul     : 23      
+ StringWTF16Get : 55      
+ StructCmpxchg  : 33      
+ StructGet      : 464     
+ StructNew      : 11370   
+ StructRMW      : 36      
+ StructSet      : 70      
+ Switch         : 4       
+ TableGet       : 3       
+ TableSet       : 50      
+ Throw          : 50      
+ ThrowRef       : 7       
+ Try            : 340     
+ TryTable       : 365     
+ TupleExtract   : 215     
+ TupleMake      : 199     
+ Unary          : 1587    
+ Unreachable    : 826     
+ WideIntAddSub  : 9       
+ WideIntMul     : 22      
diff --git a/test/passes/trap-mode-clamp.txt b/test/passes/trap-mode-clamp.txt
deleted file mode 100644
index 27512712e2a..00000000000
--- a/test/passes/trap-mode-clamp.txt
+++ /dev/null
@@ -1,573 +0,0 @@
-(module
- (type $0 (func (param i32 i32) (result i32)))
- (type $1 (func (param i64 i64) (result i64)))
- (type $2 (func (param i32 i64)))
- (type $3 (func (param f32) (result i32)))
- (type $4 (func (param f32) (result i64)))
- (type $5 (func (param f64) (result i32)))
- (type $6 (func (param f64) (result i64)))
- (type $7 (func (param f32)))
- (type $8 (func (param f64)))
- (func $test_div (param $0 i32) (param $1 i64)
-  (drop
-   (call $i32s-div
-    (local.get $0)
-    (local.get $0)
-   )
-  )
-  (drop
-   (call $i32u-div
-    (local.get $0)
-    (local.get $0)
-   )
-  )
-  (drop
-   (call $i64s-div
-    (local.get $1)
-    (local.get $1)
-   )
-  )
-  (drop
-   (call $i64u-div
-    (local.get $1)
-    (local.get $1)
-   )
-  )
- )
- (func $test_rem (param $0 i32) (param $1 i64)
-  (drop
-   (call $i32s-rem
-    (local.get $0)
-    (local.get $0)
-   )
-  )
-  (drop
-   (call $i32u-rem
-    (local.get $0)
-    (local.get $0)
-   )
-  )
-  (drop
-   (call $i64s-rem
-    (local.get $1)
-    (local.get $1)
-   )
-  )
-  (drop
-   (call $i64u-rem
-    (local.get $1)
-    (local.get $1)
-   )
-  )
- )
- (func $test_f32_to_int (param $0 f32)
-  (drop
-   (call $f32-to-int
-    (local.get $0)
-   )
-  )
-  (drop
-   (call $f32-to-uint
-    (local.get $0)
-   )
-  )
-  (drop
-   (call $f32-to-int64
-    (local.get $0)
-   )
-  )
-  (drop
-   (call $f32-to-uint64
-    (local.get $0)
-   )
-  )
- )
- (func $test_f64_to_int (param $0 f64)
-  (drop
-   (call $f64-to-int
-    (local.get $0)
-   )
-  )
-  (drop
-   (call $f64-to-uint
-    (local.get $0)
-   )
-  )
-  (drop
-   (call $f64-to-int64
-    (local.get $0)
-   )
-  )
-  (drop
-   (call $f64-to-uint64
-    (local.get $0)
-   )
-  )
- )
- (func $f32-to-int (param $0 f32) (result i32)
-  (if (result i32)
-   (f32.ne
-    (local.get $0)
-    (local.get $0)
-   )
-   (then
-    (i32.const -2147483648)
-   )
-   (else
-    (if (result i32)
-     (f32.ge
-      (local.get $0)
-      (f32.const 2147483648)
-     )
-     (then
-      (i32.const -2147483648)
-     )
-     (else
-      (if (result i32)
-       (f32.le
-        (local.get $0)
-        (f32.const -2147483648)
-       )
-       (then
-        (i32.const -2147483648)
-       )
-       (else
-        (i32.trunc_f32_s
-         (local.get $0)
-        )
-       )
-      )
-     )
-    )
-   )
-  )
- )
- (func $f32-to-int64 (param $0 f32) (result i64)
-  (if (result i64)
-   (f32.ne
-    (local.get $0)
-    (local.get $0)
-   )
-   (then
-    (i64.const -9223372036854775808)
-   )
-   (else
-    (if (result i64)
-     (f32.ge
-      (local.get $0)
-      (f32.const 9223372036854775808)
-     )
-     (then
-      (i64.const -9223372036854775808)
-     )
-     (else
-      (if (result i64)
-       (f32.le
-        (local.get $0)
-        (f32.const -9223372036854775808)
-       )
-       (then
-        (i64.const -9223372036854775808)
-       )
-       (else
-        (i64.trunc_f32_s
-         (local.get $0)
-        )
-       )
-      )
-     )
-    )
-   )
-  )
- )
- (func $f32-to-uint (param $0 f32) (result i32)
-  (if (result i32)
-   (f32.ne
-    (local.get $0)
-    (local.get $0)
-   )
-   (then
-    (i32.const 0)
-   )
-   (else
-    (if (result i32)
-     (f32.ge
-      (local.get $0)
-      (f32.const 4294967296)
-     )
-     (then
-      (i32.const 0)
-     )
-     (else
-      (if (result i32)
-       (f32.le
-        (local.get $0)
-        (f32.const -1)
-       )
-       (then
-        (i32.const 0)
-       )
-       (else
-        (i32.trunc_f32_u
-         (local.get $0)
-        )
-       )
-      )
-     )
-    )
-   )
-  )
- )
- (func $f32-to-uint64 (param $0 f32) (result i64)
-  (if (result i64)
-   (f32.ne
-    (local.get $0)
-    (local.get $0)
-   )
-   (then
-    (i64.const 0)
-   )
-   (else
-    (if (result i64)
-     (f32.ge
-      (local.get $0)
-      (f32.const 18446744073709551615)
-     )
-     (then
-      (i64.const 0)
-     )
-     (else
-      (if (result i64)
-       (f32.le
-        (local.get $0)
-        (f32.const -1)
-       )
-       (then
-        (i64.const 0)
-       )
-       (else
-        (i64.trunc_f32_u
-         (local.get $0)
-        )
-       )
-      )
-     )
-    )
-   )
-  )
- )
- (func $f64-to-int (param $0 f64) (result i32)
-  (if (result i32)
-   (f64.ne
-    (local.get $0)
-    (local.get $0)
-   )
-   (then
-    (i32.const -2147483648)
-   )
-   (else
-    (if (result i32)
-     (f64.ge
-      (local.get $0)
-      (f64.const 2147483648)
-     )
-     (then
-      (i32.const -2147483648)
-     )
-     (else
-      (if (result i32)
-       (f64.le
-        (local.get $0)
-        (f64.const -2147483649)
-       )
-       (then
-        (i32.const -2147483648)
-       )
-       (else
-        (i32.trunc_f64_s
-         (local.get $0)
-        )
-       )
-      )
-     )
-    )
-   )
-  )
- )
- (func $f64-to-int64 (param $0 f64) (result i64)
-  (if (result i64)
-   (f64.ne
-    (local.get $0)
-    (local.get $0)
-   )
-   (then
-    (i64.const -9223372036854775808)
-   )
-   (else
-    (if (result i64)
-     (f64.ge
-      (local.get $0)
-      (f64.const 9223372036854775808)
-     )
-     (then
-      (i64.const -9223372036854775808)
-     )
-     (else
-      (if (result i64)
-       (f64.le
-        (local.get $0)
-        (f64.const -9223372036854775808)
-       )
-       (then
-        (i64.const -9223372036854775808)
-       )
-       (else
-        (i64.trunc_f64_s
-         (local.get $0)
-        )
-       )
-      )
-     )
-    )
-   )
-  )
- )
- (func $f64-to-uint (param $0 f64) (result i32)
-  (if (result i32)
-   (f64.ne
-    (local.get $0)
-    (local.get $0)
-   )
-   (then
-    (i32.const 0)
-   )
-   (else
-    (if (result i32)
-     (f64.ge
-      (local.get $0)
-      (f64.const 4294967296)
-     )
-     (then
-      (i32.const 0)
-     )
-     (else
-      (if (result i32)
-       (f64.le
-        (local.get $0)
-        (f64.const -1)
-       )
-       (then
-        (i32.const 0)
-       )
-       (else
-        (i32.trunc_f64_u
-         (local.get $0)
-        )
-       )
-      )
-     )
-    )
-   )
-  )
- )
- (func $f64-to-uint64 (param $0 f64) (result i64)
-  (if (result i64)
-   (f64.ne
-    (local.get $0)
-    (local.get $0)
-   )
-   (then
-    (i64.const 0)
-   )
-   (else
-    (if (result i64)
-     (f64.ge
-      (local.get $0)
-      (f64.const 18446744073709551615)
-     )
-     (then
-      (i64.const 0)
-     )
-     (else
-      (if (result i64)
-       (f64.le
-        (local.get $0)
-        (f64.const -1)
-       )
-       (then
-        (i64.const 0)
-       )
-       (else
-        (i64.trunc_f64_u
-         (local.get $0)
-        )
-       )
-      )
-     )
-    )
-   )
-  )
- )
- (func $i32s-div (param $0 i32) (param $1 i32) (result i32)
-  (if (result i32)
-   (i32.eqz
-    (local.get $1)
-   )
-   (then
-    (i32.const 0)
-   )
-   (else
-    (if (result i32)
-     (i32.and
-      (i32.eq
-       (local.get $0)
-       (i32.const -2147483648)
-      )
-      (i32.eq
-       (local.get $1)
-       (i32.const -1)
-      )
-     )
-     (then
-      (i32.const 0)
-     )
-     (else
-      (i32.div_s
-       (local.get $0)
-       (local.get $1)
-      )
-     )
-    )
-   )
-  )
- )
- (func $i32s-rem (param $0 i32) (param $1 i32) (result i32)
-  (if (result i32)
-   (i32.eqz
-    (local.get $1)
-   )
-   (then
-    (i32.const 0)
-   )
-   (else
-    (i32.rem_s
-     (local.get $0)
-     (local.get $1)
-    )
-   )
-  )
- )
- (func $i32u-div (param $0 i32) (param $1 i32) (result i32)
-  (if (result i32)
-   (i32.eqz
-    (local.get $1)
-   )
-   (then
-    (i32.const 0)
-   )
-   (else
-    (i32.div_u
-     (local.get $0)
-     (local.get $1)
-    )
-   )
-  )
- )
- (func $i32u-rem (param $0 i32) (param $1 i32) (result i32)
-  (if (result i32)
-   (i32.eqz
-    (local.get $1)
-   )
-   (then
-    (i32.const 0)
-   )
-   (else
-    (i32.rem_u
-     (local.get $0)
-     (local.get $1)
-    )
-   )
-  )
- )
- (func $i64s-div (param $0 i64) (param $1 i64) (result i64)
-  (if (result i64)
-   (i64.eqz
-    (local.get $1)
-   )
-   (then
-    (i64.const 0)
-   )
-   (else
-    (if (result i64)
-     (i32.and
-      (i64.eq
-       (local.get $0)
-       (i64.const -9223372036854775808)
-      )
-      (i64.eq
-       (local.get $1)
-       (i64.const -1)
-      )
-     )
-     (then
-      (i64.const 0)
-     )
-     (else
-      (i64.div_s
-       (local.get $0)
-       (local.get $1)
-      )
-     )
-    )
-   )
-  )
- )
- (func $i64s-rem (param $0 i64) (param $1 i64) (result i64)
-  (if (result i64)
-   (i64.eqz
-    (local.get $1)
-   )
-   (then
-    (i64.const 0)
-   )
-   (else
-    (i64.rem_s
-     (local.get $0)
-     (local.get $1)
-    )
-   )
-  )
- )
- (func $i64u-div (param $0 i64) (param $1 i64) (result i64)
-  (if (result i64)
-   (i64.eqz
-    (local.get $1)
-   )
-   (then
-    (i64.const 0)
-   )
-   (else
-    (i64.div_u
-     (local.get $0)
-     (local.get $1)
-    )
-   )
-  )
- )
- (func $i64u-rem (param $0 i64) (param $1 i64) (result i64)
-  (if (result i64)
-   (i64.eqz
-    (local.get $1)
-   )
-   (then
-    (i64.const 0)
-   )
-   (else
-    (i64.rem_u
-     (local.get $0)
-     (local.get $1)
-    )
-   )
-  )
- )
-)
diff --git a/test/passes/trap-mode-clamp.wast b/test/passes/trap-mode-clamp.wast
deleted file mode 100644
index b62165ef54b..00000000000
--- a/test/passes/trap-mode-clamp.wast
+++ /dev/null
@@ -1,26 +0,0 @@
-(module
- (func $test_div (param $0 i32) (param $1 i64)
-  (drop (i32.div_s (local.get $0) (local.get $0)))
-  (drop (i32.div_u (local.get $0) (local.get $0)))
-  (drop (i64.div_s (local.get $1) (local.get $1)))
-  (drop (i64.div_u (local.get $1) (local.get $1)))
- )
- (func $test_rem (param $0 i32) (param $1 i64)
-  (drop (i32.rem_s (local.get $0) (local.get $0)))
-  (drop (i32.rem_u (local.get $0) (local.get $0)))
-  (drop (i64.rem_s (local.get $1) (local.get $1)))
-  (drop (i64.rem_u (local.get $1) (local.get $1)))
- )
- (func $test_f32_to_int (param $0 f32)
-  (drop (i32.trunc_f32_s (local.get $0)))
-  (drop (i32.trunc_f32_u (local.get $0)))
-  (drop (i64.trunc_f32_s (local.get $0)))
-  (drop (i64.trunc_f32_u (local.get $0)))
- )
- (func $test_f64_to_int (param $0 f64)
-  (drop (i32.trunc_f64_s (local.get $0)))
-  (drop (i32.trunc_f64_u (local.get $0)))
-  (drop (i64.trunc_f64_s (local.get $0)))
-  (drop (i64.trunc_f64_u (local.get $0)))
- )
-)
diff --git a/test/passes/trap-mode-js.txt b/test/passes/trap-mode-js.txt
deleted file mode 100644
index b43d7e9503c..00000000000
--- a/test/passes/trap-mode-js.txt
+++ /dev/null
@@ -1,425 +0,0 @@
-(module
- (type $0 (func (param i32 i32) (result i32)))
- (type $1 (func (param i64 i64) (result i64)))
- (type $2 (func (param i32 i64)))
- (type $3 (func (param f32) (result i64)))
- (type $4 (func (param f64) (result i64)))
- (type $5 (func (param f32)))
- (type $6 (func (param f64)))
- (type $7 (func (param f64) (result i32)))
- (import "asm2wasm" "f64-to-int" (func $f64-to-int (param f64) (result i32)))
- (func $test_div (param $0 i32) (param $1 i64)
-  (drop
-   (call $i32s-div
-    (local.get $0)
-    (local.get $0)
-   )
-  )
-  (drop
-   (call $i32u-div
-    (local.get $0)
-    (local.get $0)
-   )
-  )
-  (drop
-   (call $i64s-div
-    (local.get $1)
-    (local.get $1)
-   )
-  )
-  (drop
-   (call $i64u-div
-    (local.get $1)
-    (local.get $1)
-   )
-  )
- )
- (func $test_rem (param $0 i32) (param $1 i64)
-  (drop
-   (call $i32s-rem
-    (local.get $0)
-    (local.get $0)
-   )
-  )
-  (drop
-   (call $i32u-rem
-    (local.get $0)
-    (local.get $0)
-   )
-  )
-  (drop
-   (call $i64s-rem
-    (local.get $1)
-    (local.get $1)
-   )
-  )
-  (drop
-   (call $i64u-rem
-    (local.get $1)
-    (local.get $1)
-   )
-  )
- )
- (func $test_f32_to_int (param $0 f32)
-  (drop
-   (call $f64-to-int
-    (f64.promote_f32
-     (local.get $0)
-    )
-   )
-  )
-  (drop
-   (call $f64-to-int
-    (f64.promote_f32
-     (local.get $0)
-    )
-   )
-  )
-  (drop
-   (call $f32-to-int64
-    (local.get $0)
-   )
-  )
-  (drop
-   (call $f32-to-uint64
-    (local.get $0)
-   )
-  )
- )
- (func $test_f64_to_int (param $0 f64)
-  (drop
-   (call $f64-to-int
-    (local.get $0)
-   )
-  )
-  (drop
-   (call $f64-to-int
-    (local.get $0)
-   )
-  )
-  (drop
-   (call $f64-to-int64
-    (local.get $0)
-   )
-  )
-  (drop
-   (call $f64-to-uint64
-    (local.get $0)
-   )
-  )
- )
- (func $f32-to-int64 (param $0 f32) (result i64)
-  (if (result i64)
-   (f32.ne
-    (local.get $0)
-    (local.get $0)
-   )
-   (then
-    (i64.const -9223372036854775808)
-   )
-   (else
-    (if (result i64)
-     (f32.ge
-      (local.get $0)
-      (f32.const 9223372036854775808)
-     )
-     (then
-      (i64.const -9223372036854775808)
-     )
-     (else
-      (if (result i64)
-       (f32.le
-        (local.get $0)
-        (f32.const -9223372036854775808)
-       )
-       (then
-        (i64.const -9223372036854775808)
-       )
-       (else
-        (i64.trunc_f32_s
-         (local.get $0)
-        )
-       )
-      )
-     )
-    )
-   )
-  )
- )
- (func $f32-to-uint64 (param $0 f32) (result i64)
-  (if (result i64)
-   (f32.ne
-    (local.get $0)
-    (local.get $0)
-   )
-   (then
-    (i64.const 0)
-   )
-   (else
-    (if (result i64)
-     (f32.ge
-      (local.get $0)
-      (f32.const 18446744073709551615)
-     )
-     (then
-      (i64.const 0)
-     )
-     (else
-      (if (result i64)
-       (f32.le
-        (local.get $0)
-        (f32.const -1)
-       )
-       (then
-        (i64.const 0)
-       )
-       (else
-        (i64.trunc_f32_u
-         (local.get $0)
-        )
-       )
-      )
-     )
-    )
-   )
-  )
- )
- (func $f64-to-int64 (param $0 f64) (result i64)
-  (if (result i64)
-   (f64.ne
-    (local.get $0)
-    (local.get $0)
-   )
-   (then
-    (i64.const -9223372036854775808)
-   )
-   (else
-    (if (result i64)
-     (f64.ge
-      (local.get $0)
-      (f64.const 9223372036854775808)
-     )
-     (then
-      (i64.const -9223372036854775808)
-     )
-     (else
-      (if (result i64)
-       (f64.le
-        (local.get $0)
-        (f64.const -9223372036854775808)
-       )
-       (then
-        (i64.const -9223372036854775808)
-       )
-       (else
-        (i64.trunc_f64_s
-         (local.get $0)
-        )
-       )
-      )
-     )
-    )
-   )
-  )
- )
- (func $f64-to-uint64 (param $0 f64) (result i64)
-  (if (result i64)
-   (f64.ne
-    (local.get $0)
-    (local.get $0)
-   )
-   (then
-    (i64.const 0)
-   )
-   (else
-    (if (result i64)
-     (f64.ge
-      (local.get $0)
-      (f64.const 18446744073709551615)
-     )
-     (then
-      (i64.const 0)
-     )
-     (else
-      (if (result i64)
-       (f64.le
-        (local.get $0)
-        (f64.const -1)
-       )
-       (then
-        (i64.const 0)
-       )
-       (else
-        (i64.trunc_f64_u
-         (local.get $0)
-        )
-       )
-      )
-     )
-    )
-   )
-  )
- )
- (func $i32s-div (param $0 i32) (param $1 i32) (result i32)
-  (if (result i32)
-   (i32.eqz
-    (local.get $1)
-   )
-   (then
-    (i32.const 0)
-   )
-   (else
-    (if (result i32)
-     (i32.and
-      (i32.eq
-       (local.get $0)
-       (i32.const -2147483648)
-      )
-      (i32.eq
-       (local.get $1)
-       (i32.const -1)
-      )
-     )
-     (then
-      (i32.const 0)
-     )
-     (else
-      (i32.div_s
-       (local.get $0)
-       (local.get $1)
-      )
-     )
-    )
-   )
-  )
- )
- (func $i32s-rem (param $0 i32) (param $1 i32) (result i32)
-  (if (result i32)
-   (i32.eqz
-    (local.get $1)
-   )
-   (then
-    (i32.const 0)
-   )
-   (else
-    (i32.rem_s
-     (local.get $0)
-     (local.get $1)
-    )
-   )
-  )
- )
- (func $i32u-div (param $0 i32) (param $1 i32) (result i32)
-  (if (result i32)
-   (i32.eqz
-    (local.get $1)
-   )
-   (then
-    (i32.const 0)
-   )
-   (else
-    (i32.div_u
-     (local.get $0)
-     (local.get $1)
-    )
-   )
-  )
- )
- (func $i32u-rem (param $0 i32) (param $1 i32) (result i32)
-  (if (result i32)
-   (i32.eqz
-    (local.get $1)
-   )
-   (then
-    (i32.const 0)
-   )
-   (else
-    (i32.rem_u
-     (local.get $0)
-     (local.get $1)
-    )
-   )
-  )
- )
- (func $i64s-div (param $0 i64) (param $1 i64) (result i64)
-  (if (result i64)
-   (i64.eqz
-    (local.get $1)
-   )
-   (then
-    (i64.const 0)
-   )
-   (else
-    (if (result i64)
-     (i32.and
-      (i64.eq
-       (local.get $0)
-       (i64.const -9223372036854775808)
-      )
-      (i64.eq
-       (local.get $1)
-       (i64.const -1)
-      )
-     )
-     (then
-      (i64.const 0)
-     )
-     (else
-      (i64.div_s
-       (local.get $0)
-       (local.get $1)
-      )
-     )
-    )
-   )
-  )
- )
- (func $i64s-rem (param $0 i64) (param $1 i64) (result i64)
-  (if (result i64)
-   (i64.eqz
-    (local.get $1)
-   )
-   (then
-    (i64.const 0)
-   )
-   (else
-    (i64.rem_s
-     (local.get $0)
-     (local.get $1)
-    )
-   )
-  )
- )
- (func $i64u-div (param $0 i64) (param $1 i64) (result i64)
-  (if (result i64)
-   (i64.eqz
-    (local.get $1)
-   )
-   (then
-    (i64.const 0)
-   )
-   (else
-    (i64.div_u
-     (local.get $0)
-     (local.get $1)
-    )
-   )
-  )
- )
- (func $i64u-rem (param $0 i64) (param $1 i64) (result i64)
-  (if (result i64)
-   (i64.eqz
-    (local.get $1)
-   )
-   (then
-    (i64.const 0)
-   )
-   (else
-    (i64.rem_u
-     (local.get $0)
-     (local.get $1)
-    )
-   )
-  )
- )
-)
diff --git a/test/passes/trap-mode-js.wast b/test/passes/trap-mode-js.wast
deleted file mode 100644
index b62165ef54b..00000000000
--- a/test/passes/trap-mode-js.wast
+++ /dev/null
@@ -1,26 +0,0 @@
-(module
- (func $test_div (param $0 i32) (param $1 i64)
-  (drop (i32.div_s (local.get $0) (local.get $0)))
-  (drop (i32.div_u (local.get $0) (local.get $0)))
-  (drop (i64.div_s (local.get $1) (local.get $1)))
-  (drop (i64.div_u (local.get $1) (local.get $1)))
- )
- (func $test_rem (param $0 i32) (param $1 i64)
-  (drop (i32.rem_s (local.get $0) (local.get $0)))
-  (drop (i32.rem_u (local.get $0) (local.get $0)))
-  (drop (i64.rem_s (local.get $1) (local.get $1)))
-  (drop (i64.rem_u (local.get $1) (local.get $1)))
- )
- (func $test_f32_to_int (param $0 f32)
-  (drop (i32.trunc_f32_s (local.get $0)))
-  (drop (i32.trunc_f32_u (local.get $0)))
-  (drop (i64.trunc_f32_s (local.get $0)))
-  (drop (i64.trunc_f32_u (local.get $0)))
- )
- (func $test_f64_to_int (param $0 f64)
-  (drop (i32.trunc_f64_s (local.get $0)))
-  (drop (i32.trunc_f64_u (local.get $0)))
-  (drop (i64.trunc_f64_s (local.get $0)))
-  (drop (i64.trunc_f64_u (local.get $0)))
- )
-)
diff --git a/test/spec/acquire-release-atomics/threaded.wast b/test/spec/acquire-release-atomics/threaded.wast
index d6f64527f93..dd195a65065 100644
--- a/test/spec/acquire-release-atomics/threaded.wast
+++ b/test/spec/acquire-release-atomics/threaded.wast
@@ -1,10 +1,11 @@
 ;; Interleaving stores
-(module $Mem
+(module $Mem1
   (memory (export "shared") 1 1 shared)
 )
-(register "mem" $Mem)
+(register "mem" $Mem1)
 
-(thread $T1 (shared (module $Mem))
+(thread $T1 (shared (module $Mem1))
+  (register "mem" $Mem1)
   (module
     (memory (import "mem" "shared") 1 1 shared)
     (func (export "run")
@@ -17,7 +18,8 @@
   (invoke "run")
 )
 
-(thread $T2 (shared (module $Mem))
+(thread $T2 (shared (module $Mem1))
+  (register "mem" $Mem1)
   (module
     (memory (import "mem" "shared") 1 1 shared)
     (func (export "run")
@@ -51,12 +53,14 @@
 )
 
 ;; Critical section guarding an unordered memory access
-(module $Mem
+(module $Mem2
   (memory (export "shared") 1 1 shared)
 )
-(register "mem" $Mem)
+(register "mem" $Mem2)
+
+(thread $write (shared (module $Mem2))
+  (register "mem" $Mem2)
 
-(thread $writer (shared (module $Mem))
   (module
     (memory (import "mem" "shared") 1 1 shared)
     (func (export "run")
@@ -69,7 +73,9 @@
   (invoke "run")
 )
 
-(thread $reader (shared (module $Mem))
+(thread $read (shared (module $Mem2))
+  (register "mem" $Mem2)
+
   (module
     (memory (import "mem" "shared") 1 1 shared)
     (func (export "run")
@@ -83,8 +89,8 @@
   (invoke "run")
 )
 
-(wait $writer)
-(wait $reader)
+(wait $write)
+(wait $read)
 
 (module
   (memory (import "mem" "shared") 1 1 shared)
@@ -104,12 +110,14 @@
 )
 
 ;; Similar to above, critical section guarding a flag
-(module $Mem
+(module $Mem3
   (memory (export "shared") 1 1 shared)
 )
-(register "mem" $Mem)
+(register "mem" $Mem3)
+
+(thread $write_flag (shared (module $Mem3))
+  (register "mem" $Mem3)
 
-(thread $writer (shared (module $Mem))
   (module
     (memory (import "mem" "shared") 1 1 shared)
     (func (export "run")
@@ -130,7 +138,9 @@
   (invoke "run")
 )
 
-(thread $reader (shared (module $Mem))
+(thread $read_flag (shared (module $Mem3))
+  (register "mem" $Mem3)
+
   (module
     (memory (import "mem" "shared") 1 1 shared)
     (func (export "run")
@@ -149,8 +159,8 @@
   (invoke "run")
 )
 
-(wait $writer)
-(wait $reader)
+(wait $write_flag)
+(wait $read_flag)
 
 (module
   (memory (import "mem" "shared") 1 1 shared)
@@ -170,15 +180,17 @@
 )
 
 ;; Spinlock
-(module $Mem
+(module $Mem4
   ;; Address 0 - lock
   ;; Address 4 - payload
   (memory (export "shared") 1 1 shared)
 )
-(register "mem" $Mem)
+(register "mem" $Mem4)
 
 ;; Add 1 to the counter atomically
-(thread $addOne (shared (module $Mem))
+(thread $addOne (shared (module $Mem4))
+  (register "mem" $Mem4)
+
   (module
     (memory (import "mem" "shared") 1 1 shared)
     
@@ -213,7 +225,9 @@
 )
 
 ;; Add 10 to the counter atomically
-(thread $addTen (shared (module $Mem))
+(thread $addTen (shared (module $Mem4))
+  (register "mem" $Mem4)
+
   (module
     (memory (import "mem" "shared") 1 1 shared)
     
@@ -267,12 +281,14 @@
 )
 
 ;; independent reads of independent writes
-(module $Mem
+(module $Mem5
   (memory (export "shared") 1 1 shared)
 )
-(register "mem" $Mem)
+(register "mem" $Mem5)
+
+(thread $writeX (shared (module $Mem5))
+  (register "mem" $Mem5)
 
-(thread $writerX (shared (module $Mem))
   (module
     (memory (import "mem" "shared") 1 1 shared)
     (func (export "run")
@@ -283,7 +299,9 @@
   (invoke "run")
 )
 
-(thread $writerY (shared (module $Mem))
+(thread $writeY (shared (module $Mem5))
+  (register "mem" $Mem5)
+
   (module
     (memory (import "mem" "shared") 1 1 shared)
     (func (export "run")
@@ -294,7 +312,9 @@
   (invoke "run")
 )
 
-(thread $reader1 (shared (module $Mem))
+(thread $read1 (shared (module $Mem5))
+  (register "mem" $Mem5)
+
   (module
     (memory (import "mem" "shared") 1 1 shared)
     (func (export "run")
@@ -307,7 +327,9 @@
   (invoke "run")
 )
 
-(thread $reader2 (shared (module $Mem))
+(thread $read2 (shared (module $Mem5))
+  (register "mem" $Mem5)
+
   (module
     (memory (import "mem" "shared") 1 1 shared)
     (func (export "run")
@@ -320,10 +342,10 @@
   (invoke "run")
 )
 
-(wait $writerX)
-(wait $writerY)
-(wait $reader1)
-(wait $reader2)
+(wait $writeX)
+(wait $writeY)
+(wait $read1)
+(wait $read2)
 
 (module
   (memory (import "mem" "shared") 1 1 shared)
diff --git a/test/spec/descriptors.wast b/test/spec/descriptors.wast
index 633ca7d20c0..75788503e63 100644
--- a/test/spec/descriptors.wast
+++ b/test/spec/descriptors.wast
@@ -159,3 +159,41 @@
   )
   "supertype of non-descriptor type cannot be a descriptor"
 )
+
+;; Descriptor and described types must have matching finality.
+(assert_invalid
+  (module
+    (rec
+      (type $a (sub final (descriptor $b) (struct)))
+      (type $b (sub (describes $a) (struct)))
+    )
+  )
+  "descriptor and described types have mismatched finality"
+)
+(assert_invalid
+  (module
+    (rec
+      (type $x (sub (descriptor $y) (struct)))
+      (type $y (sub final (describes $x) (struct)))
+    )
+  )
+  "descriptor and described types have mismatched finality"
+)
+(assert_invalid
+  (module
+    (rec
+      (type $a (descriptor $b) (struct))
+      (type $b (sub (describes $a) (struct)))
+    )
+  )
+  "descriptor and described types have mismatched finality"
+)
+(assert_invalid
+  (module
+    (rec
+      (type $x (sub (descriptor $y) (struct)))
+      (type $y (describes $x) (struct))
+    )
+  )
+  "descriptor and described types have mismatched finality"
+)
diff --git a/test/spec/gc-elem-declare.wast b/test/spec/gc-elem-declare.wast
new file mode 100644
index 00000000000..347841aa0e9
--- /dev/null
+++ b/test/spec/gc-elem-declare.wast
@@ -0,0 +1,28 @@
+;; Binary spec test for declarative element segments with GC reftypes.
+;; Before the fix, parsing this module failed with "invalid tag index".
+;; See https://github.com/WebAssembly/binaryen/issues/8540
+
+(module binary
+  "\00asm" "\01\00\00\00"    ;; magic + version
+
+  "\01\1b"                   ;; Type section, 27 bytes
+  "\01"                      ;;   1 rec group
+  "\4e\06"                   ;;   rec group of size 6
+  "\5e\77\00"                ;;   type 0: (array i16)
+  "\50\00\5f\00"             ;;   type 1: (sub (struct))
+  "\5e\72\01"                ;;   type 2: (array (mut nullexternref))
+  "\50\00\60\01\7e\00"       ;;   type 3: (sub (func (param i64)))
+  "\5e\7d\01"                ;;   type 4: (array (mut f32))
+  "\50\00\5e\7b\01"          ;;   type 5: (sub (array (mut v128)))
+
+  "\03\03\02\03\03"          ;; Function section: 2 funcs, both type 3
+
+  "\09\0f\03"                ;; Element section, 15 bytes
+  "\07\63\02\00"             ;;   segment 0: declare (ref null 2), 0 exprs
+  "\07\63\03\01\d0\03\0b"    ;;   segment 1: declare (ref null 3) (ref.null 3)
+  "\07\71\00"                ;;   segment 2: declare nullref, 0 exprs
+
+  "\0a\07\02"                ;; Code section, 7 bytes
+  "\02\00\0b"                ;;   function 0: empty body
+  "\02\00\0b"                ;;   function 1: empty body
+)
diff --git a/test/spec/stack-switching/resume_throw.wast b/test/spec/stack-switching/resume_throw.wast
index 14f44e7f0db..8e00c63f5fc 100644
--- a/test/spec/stack-switching/resume_throw.wast
+++ b/test/spec/stack-switching/resume_throw.wast
@@ -277,7 +277,7 @@
     (func 
       (ref.null $ct)   
       (i32.const 0)
-      (resume_throw $ct $exn) ;; exception tag does not take paramter
+      (resume_throw $ct $exn) ;; exception tag does not take parameter
       (unreachable)))
   "type mismatch")
 
diff --git a/test/unit/test_cluster_fuzz.py b/test/unit/test_cluster_fuzz.py
index e40c449be4b..578ec2690a5 100644
--- a/test/unit/test_cluster_fuzz.py
+++ b/test/unit/test_cluster_fuzz.py
@@ -452,7 +452,7 @@ def test_file_contents(self):
                 # An execution is valid if we exited without error, and if we
                 # managed to run some code before exiting (modules with no
                 # exports will be considered "invalid" here, but that is very
-                # rare, and in a sense they are actually unuseful).
+                # rare, and in a sense they are actually useless).
                 if proc.returncode == 0 and b'[fuzz-exec] export ' in proc.stdout:
                     valid_executions += 1
                 else:
diff --git a/test/unit/test_fuzz_stats.py b/test/unit/test_fuzz_stats.py
new file mode 100644
index 00000000000..a3ab0a48b3f
--- /dev/null
+++ b/test/unit/test_fuzz_stats.py
@@ -0,0 +1,178 @@
+import os
+import platform
+import tempfile
+import unittest
+
+from scripts.test import shared
+
+from . import utils
+
+
+def parse_stats(content):
+    stats = {
+        'modules': None,
+        'functions': None,
+        'patterns': {},
+    }
+    section = None
+    for raw_line in content.strip().splitlines():
+        line = raw_line.strip()
+        if not line or line.startswith('#'):
+            continue
+        if line == 'Patterns:':
+            section = 'patterns'
+            continue
+        if line == 'Events:':
+            section = 'events'
+            continue
+        if section == 'patterns':
+            parts = line.split()
+            name = parts[0]
+            stats['patterns'][name] = {
+                'occurrences': int(parts[1]),
+                'modules': int(parts[4]),
+                'functions': int(parts[6]),
+            }
+            continue
+        if line.startswith('Modules:'):
+            stats['modules'] = int(line.split(':')[1].strip())
+        elif line.startswith('Functions:'):
+            stats['functions'] = int(line.split(':')[1].strip())
+    return stats
+
+
+class FuzzStatsTest(utils.BinaryenTestCase):
+    def test_stats_file_created(self):
+        with tempfile.TemporaryDirectory() as temp_dir:
+            stats_path = os.path.join(temp_dir, 'stats.txt')
+            random_data = self.input_path('random_data.txt')
+            env = dict(os.environ, BINARYEN_FUZZ_STATS=stats_path)
+
+            shared.run_process(
+                shared.WASM_OPT + [
+                    '-ttf', random_data, '-q', '-o', os.devnull,
+                ],
+                env=env,
+            )
+
+            self.assertTrue(os.path.exists(stats_path))
+            with open(stats_path) as f:
+                content = f.read()
+
+            self.assertIn('# Binaryen Fuzzing Statistics', content)
+            stats = parse_stats(content)
+            self.assertEqual(stats['modules'], 1)
+            self.assertIsNotNone(stats['functions'])
+
+    @unittest.skipIf(platform.system() == 'Windows',
+                     'Windows line endings affect random data PRNG seed')
+    def test_stats_file_updated_across_invocations(self):
+        with tempfile.TemporaryDirectory() as temp_dir:
+            stats_path = os.path.join(temp_dir, 'stats.txt')
+            wat_path = os.path.join(temp_dir, 'test.wat')
+            with open(wat_path, 'w') as f:
+                f.write(
+                    """(module
+  (func $foo (param $x (ref null any)) (result (ref null any))
+    (drop (ref.test (ref null any) (local.get $x)))
+    (drop (ref.cast (ref null any) (local.get $x)))
+    (local.get $x)
+  )
+)""",
+                )
+
+            random_data = self.input_path('random_data.txt')
+            env = dict(os.environ, BINARYEN_FUZZ_STATS=stats_path)
+            cmd = shared.WASM_OPT + [
+                '-ttf',
+                random_data,
+                f'--initial-fuzz={wat_path}',
+                '--all-features',
+                '-q',
+                '-o',
+                os.devnull,
+            ]
+
+            # First invocation
+            shared.run_process(cmd, env=env)
+            with open(stats_path) as f:
+                stats1 = parse_stats(f.read())
+
+            self.assertEqual(stats1['modules'], 1)
+            self.assertEqual(stats1['functions'], 1)
+            self.assertIn('ref_cast', stats1['patterns'])
+            self.assertIn('ref_test', stats1['patterns'])
+            self.assertEqual(stats1['patterns']['ref_cast']['occurrences'], 1)
+            self.assertEqual(stats1['patterns']['ref_cast']['modules'], 1)
+            self.assertEqual(stats1['patterns']['ref_test']['occurrences'], 1)
+            self.assertEqual(stats1['patterns']['ref_test']['modules'], 1)
+
+            # Second invocation
+            shared.run_process(cmd, env=env)
+            with open(stats_path) as f:
+                stats2 = parse_stats(f.read())
+
+            self.assertEqual(stats2['modules'], 2)
+            self.assertEqual(stats2['functions'], 2)
+            self.assertEqual(stats2['patterns']['ref_cast']['occurrences'], 2)
+            self.assertEqual(stats2['patterns']['ref_cast']['modules'], 2)
+            self.assertEqual(stats2['patterns']['ref_test']['occurrences'], 2)
+            self.assertEqual(stats2['patterns']['ref_test']['modules'], 2)
+
+            # Third invocation without initial-fuzz (empty function count)
+            empty_cmd = shared.WASM_OPT + [
+                '-ttf',
+                random_data,
+                '-q',
+                '-o',
+                os.devnull,
+            ]
+            shared.run_process(empty_cmd, env=env)
+            with open(stats_path) as f:
+                stats3 = parse_stats(f.read())
+
+            self.assertEqual(stats3['modules'], 3)
+            self.assertEqual(stats3['functions'], 2)
+            # Pattern occurrences shouldn't change for module with no casts
+            self.assertEqual(stats3['patterns']['ref_cast']['occurrences'], 2)
+            self.assertEqual(stats3['patterns']['ref_cast']['modules'], 2)
+
+    def test_stats_not_created_when_disabled(self):
+        with tempfile.TemporaryDirectory() as temp_dir:
+            stats_path = os.path.join(temp_dir, 'stats.txt')
+            random_data = self.input_path('random_data.txt')
+            env = {
+                k: v for k, v in os.environ.items()
+                if k != 'BINARYEN_FUZZ_STATS'
+            }
+
+            shared.run_process(
+                shared.WASM_OPT + [
+                    '-ttf', random_data, '-q', '-o', os.devnull,
+                ],
+                env=env,
+                cwd=temp_dir,
+            )
+
+            self.assertFalse(os.path.exists(stats_path))
+            default_stats = os.path.join(temp_dir, 'fuzz-stats.txt')
+            self.assertFalse(os.path.exists(default_stats))
+
+    def test_default_filename(self):
+        with tempfile.TemporaryDirectory() as temp_dir:
+            random_data = self.input_path('random_data.txt')
+            env = dict(os.environ, BINARYEN_FUZZ_STATS='1')
+
+            shared.run_process(
+                shared.WASM_OPT + [
+                    '-ttf', random_data, '-q', '-o', os.devnull,
+                ],
+                env=env,
+                cwd=temp_dir,
+            )
+
+            default_stats = os.path.join(temp_dir, 'fuzz-stats.txt')
+            self.assertTrue(os.path.exists(default_stats))
+            with open(default_stats) as f:
+                stats = parse_stats(f.read())
+            self.assertEqual(stats['modules'], 1)