;; RUN: wasm2js --help | filecheck %s
;; CHECK: ================================================================================
;; CHECK-NEXT: wasm2js INFILE
;; CHECK-NEXT:
;; CHECK-NEXT: Transform .wasm/.wat files to asm.js
;; CHECK-NEXT: ================================================================================
;; CHECK-NEXT:
;; CHECK-NEXT:
;; CHECK-NEXT: wasm2js options:
;; CHECK-NEXT: ----------------
;; CHECK-NEXT:
;; CHECK-NEXT:   --output,-o                                   Output file (stdout if not
;; CHECK-NEXT:                                                 specified)
;; CHECK-NEXT:
;; CHECK-NEXT:   --allow-asserts                               Allow compilation of .wast
;; CHECK-NEXT:                                                 testing asserts
;; CHECK-NEXT:
;; 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-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-NEXT:                                                 not vary)
;; CHECK-NEXT:
;; 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-NEXT: Optimization passes:
;; CHECK-NEXT: --------------------
;; CHECK-NEXT:
;; CHECK-NEXT:   --abstract-type-refining                      refine and merge abstract
;; CHECK-NEXT:                                                 (never-created) types
;; CHECK-NEXT:
;; 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-NEXT:                                                 allowing pausing and resuming
;; CHECK-NEXT:
;; CHECK-NEXT:   --avoid-reinterprets                          Tries to avoid reinterpret
;; CHECK-NEXT:                                                 operations via more loads
;; CHECK-NEXT:
;; CHECK-NEXT:   --cfp                                         propagate constant struct field
;; CHECK-NEXT:                                                 values
;; CHECK-NEXT:
;; CHECK-NEXT:   --cfp-reftest                                 propagate constant struct field
;; CHECK-NEXT:                                                 values, using ref.test
;; CHECK-NEXT:
;; CHECK-NEXT:   --coalesce-locals                             reduce # of locals by coalescing
;; CHECK-NEXT:
;; CHECK-NEXT:   --coalesce-locals-learning                    reduce # of locals by coalescing
;; CHECK-NEXT:                                                 and learning
;; CHECK-NEXT:
;; CHECK-NEXT:   --code-folding                                fold code, merging duplicates
;; CHECK-NEXT:
;; 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-NEXT:                                                 local
;; CHECK-NEXT:
;; CHECK-NEXT:   --dae                                         removes arguments to calls in an
;; CHECK-NEXT:                                                 lto-like manner
;; CHECK-NEXT:
;; CHECK-NEXT:   --dae-optimizing                              removes arguments to calls in an
;; CHECK-NEXT:                                                 lto-like manner, and optimizes
;; CHECK-NEXT:                                                 where we removed
;; CHECK-NEXT:
;; CHECK-NEXT:   --dce                                         removes unreachable code
;; CHECK-NEXT:
;; 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-NEXT:                                                 NaNs into 0 at runtime
;; CHECK-NEXT:
;; CHECK-NEXT:   --dfo                                         optimizes using the DataFlow SSA
;; CHECK-NEXT:                                                 IR
;; CHECK-NEXT:
;; CHECK-NEXT:   --directize                                   turns indirect calls into direct
;; CHECK-NEXT:                                                 ones
;; CHECK-NEXT:
;; CHECK-NEXT:   --discard-global-effects                      discards global effect info
;; CHECK-NEXT:
;; CHECK-NEXT:   --duplicate-function-elimination              removes duplicate functions
;; CHECK-NEXT:
;; CHECK-NEXT:   --duplicate-import-elimination                removes duplicate imports
;; CHECK-NEXT:
;; CHECK-NEXT:   --dwarfdump                                   dump DWARF debug info sections
;; CHECK-NEXT:                                                 from the read binary
;; CHECK-NEXT:
;; CHECK-NEXT:   --emit-target-features                        emit the target features section
;; CHECK-NEXT:                                                 in the output
;; CHECK-NEXT:
;; 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-NEXT:                                                 selected by index
;; CHECK-NEXT:
;; CHECK-NEXT:   --flatten                                     flattens out code, removing
;; CHECK-NEXT:                                                 nesting
;; CHECK-NEXT:
;; CHECK-NEXT:   --fpcast-emu                                  emulates function pointer casts,
;; CHECK-NEXT:                                                 allowing incorrect indirect
;; CHECK-NEXT:                                                 calls to (sometimes) work
;; CHECK-NEXT:
;; CHECK-NEXT:   --func-metrics                                reports function metrics
;; CHECK-NEXT:
;; CHECK-NEXT:   --generate-dyncalls                           generate dynCall fuctions used
;; CHECK-NEXT:                                                 by emscripten ABI
;; CHECK-NEXT:
;; 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-NEXT:                                                 support).
;; CHECK-NEXT:
;; CHECK-NEXT:   --global-refining                             refine the types of globals
;; CHECK-NEXT:
;; CHECK-NEXT:   --gsi                                         globally optimize struct values
;; CHECK-NEXT:
;; 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-NEXT:                                                 each location
;; CHECK-NEXT:
;; CHECK-NEXT:   --gufa-cast-all                               GUFA plus add casts for all
;; CHECK-NEXT:                                                 inferences
;; CHECK-NEXT:
;; CHECK-NEXT:   --gufa-optimizing                             GUFA plus local optimizations in
;; CHECK-NEXT:                                                 functions we modified
;; CHECK-NEXT:
;; CHECK-NEXT:   --heap-store-optimization                     optimize heap (GC) stores
;; CHECK-NEXT:
;; 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-NEXT:                                                 i32s instead
;; CHECK-NEXT:
;; CHECK-NEXT:   --inline-main                                 inline __original_main into main
;; CHECK-NEXT:
;; CHECK-NEXT:   --inlining                                    inline functions (you probably
;; CHECK-NEXT:                                                 want inlining-optimizing)
;; CHECK-NEXT:
;; CHECK-NEXT:   --inlining-optimizing                         inline functions and optimizes
;; CHECK-NEXT:                                                 where we inlined
;; CHECK-NEXT:
;; 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-NEXT:                                                 stores
;; CHECK-NEXT:
;; CHECK-NEXT:   --intrinsic-lowering                          lower away binaryen intrinsics
;; CHECK-NEXT:
;; CHECK-NEXT:   --jspi                                        wrap imports and exports for
;; CHECK-NEXT:                                                 JavaScript promise integration
;; CHECK-NEXT:
;; 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-NEXT:                                                 import/export boundary
;; CHECK-NEXT:
;; CHECK-NEXT:   --licm                                        loop invariant code motion
;; CHECK-NEXT:
;; CHECK-NEXT:   --limit-segments                              attempt to merge segments to fit
;; CHECK-NEXT:                                                 within web limits
;; CHECK-NEXT:
;; CHECK-NEXT:   --local-cse                                   common subexpression elimination
;; CHECK-NEXT:                                                 inside basic blocks
;; CHECK-NEXT:
;; 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-NEXT:                                                 logging of where execution goes
;; CHECK-NEXT:
;; 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-NEXT:                                                 32-bit one
;; CHECK-NEXT:
;; 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-NEXT:                                                 compact
;; CHECK-NEXT:
;; 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-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-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-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-NEXT:                                                 the modules as well
;; CHECK-NEXT:
;; CHECK-NEXT:   --minimize-rec-groups                         Split types into minimal
;; CHECK-NEXT:                                                 recursion groups
;; CHECK-NEXT:
;; CHECK-NEXT:   --mod-asyncify-always-and-only-unwind         apply the assumption that
;; CHECK-NEXT:                                                 asyncify imports always unwind,
;; CHECK-NEXT:                                                 and we never rewind
;; CHECK-NEXT:
;; CHECK-NEXT:   --mod-asyncify-never-unwind                   apply the assumption that
;; CHECK-NEXT:                                                 asyncify never unwinds
;; CHECK-NEXT:
;; CHECK-NEXT:   --monomorphize                                creates specialized versions of
;; CHECK-NEXT:                                                 functions
;; CHECK-NEXT:
;; 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-NEXT:                                                 a single memory
;; CHECK-NEXT:
;; 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-NEXT:   --name-types                                  (re)name all heap types
;; CHECK-NEXT:
;; CHECK-NEXT:   --nm                                          name list
;; CHECK-NEXT:
;; CHECK-NEXT:   --no-full-inline                              mark functions as no-inline (for
;; CHECK-NEXT:                                                 full inlining only)
;; CHECK-NEXT:
;; CHECK-NEXT:   --no-inline                                   mark functions as no-inline
;; CHECK-NEXT:
;; 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-NEXT:                                                 runs once
;; CHECK-NEXT:
;; 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-NEXT:                                                 them across locals too
;; CHECK-NEXT:
;; CHECK-NEXT:   --optimize-casts                              eliminate and reuse casts
;; CHECK-NEXT:
;; CHECK-NEXT:   --optimize-for-js                             early optimize of the
;; CHECK-NEXT:                                                 instruction combinations for js
;; CHECK-NEXT:
;; CHECK-NEXT:   --optimize-instructions                       optimizes instruction
;; CHECK-NEXT:                                                 combinations
;; CHECK-NEXT:
;; CHECK-NEXT:   --optimize-j2cl                               optimizes J2CL specific
;; CHECK-NEXT:                                                 constructs.
;; CHECK-NEXT:
;; CHECK-NEXT:   --outlining                                   outline instructions
;; CHECK-NEXT:
;; CHECK-NEXT:   --pick-load-signs                             pick load signs based on their
;; CHECK-NEXT:                                                 uses
;; CHECK-NEXT:
;; CHECK-NEXT:   --poppify                                     Tranform Binaryen IR into Poppy
;; CHECK-NEXT:                                                 IR
;; CHECK-NEXT:
;; CHECK-NEXT:   --post-emscripten                             miscellaneous optimizations for
;; CHECK-NEXT:                                                 Emscripten-generated code
;; CHECK-NEXT:
;; 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-NEXT:                                                 propagates them through locals
;; CHECK-NEXT:
;; CHECK-NEXT:   --print                                       print in s-expression format
;; CHECK-NEXT:
;; CHECK-NEXT:   --print-call-graph                            print call graph
;; CHECK-NEXT:
;; CHECK-NEXT:   --print-features                              print options for enabled
;; CHECK-NEXT:                                                 features
;; CHECK-NEXT:
;; 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-NEXT:                                                 to names
;; CHECK-NEXT:
;; 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-NEXT:                                                 child nodes
;; CHECK-NEXT:
;; CHECK-NEXT:   --propagate-globals-globally                  propagate global values to other
;; CHECK-NEXT:                                                 globals (useful for tests)
;; CHECK-NEXT:
;; CHECK-NEXT:   --remove-imports                              removes imports and replaces
;; CHECK-NEXT:                                                 them with nops
;; CHECK-NEXT:
;; CHECK-NEXT:   --remove-memory                               removes memory segments
;; CHECK-NEXT:
;; CHECK-NEXT:   --remove-non-js-ops                           removes operations incompatible
;; CHECK-NEXT:                                                 with js
;; CHECK-NEXT:
;; CHECK-NEXT:   --remove-unused-brs                           removes breaks from locations
;; CHECK-NEXT:                                                 that are not needed
;; CHECK-NEXT:
;; CHECK-NEXT:   --remove-unused-module-elements               removes unused module elements
;; CHECK-NEXT:
;; 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-NEXT:                                                 that are not functions
;; CHECK-NEXT:
;; CHECK-NEXT:   --remove-unused-types                         remove unused private GC types
;; CHECK-NEXT:
;; 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-NEXT:                                                 for debugging)
;; CHECK-NEXT:
;; CHECK-NEXT:   --reorder-globals                             sorts globals by access
;; CHECK-NEXT:                                                 frequency
;; CHECK-NEXT:
;; CHECK-NEXT:   --reorder-locals                              sorts locals by access frequency
;; CHECK-NEXT:
;; CHECK-NEXT:   --rereloop                                    re-optimize control flow using
;; CHECK-NEXT:                                                 the relooper algorithm
;; CHECK-NEXT:
;; CHECK-NEXT:   --roundtrip                                   write the module to binary, then
;; CHECK-NEXT:                                                 read it
;; CHECK-NEXT:
;; CHECK-NEXT:   --rse                                         remove redundant local.sets
;; CHECK-NEXT:
;; 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-NEXT:                                                 and strip them from the module
;; CHECK-NEXT:
;; CHECK-NEXT:   --set-globals                                 sets specified globals to
;; CHECK-NEXT:                                                 specified values
;; CHECK-NEXT:
;; 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-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-NEXT:                                                 extension feature
;; CHECK-NEXT:
;; 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-NEXT:                                                 with constants
;; CHECK-NEXT:
;; 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-NEXT:                                                 all; preserves flatness)
;; CHECK-NEXT:
;; CHECK-NEXT:   --simplify-locals-nostructure                 miscellaneous locals-related
;; CHECK-NEXT:                                                 optimizations (no structure)
;; CHECK-NEXT:
;; 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-NEXT:                                                 structure)
;; CHECK-NEXT:
;; CHECK-NEXT:   --souperify                                   emit Souper IR in text form
;; CHECK-NEXT:
;; 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-NEXT:                                                 (useful for Boehm-style GC)
;; CHECK-NEXT:
;; 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-NEXT:                                                 ignoring merges
;; CHECK-NEXT:
;; CHECK-NEXT:   --stack-check                                 enforce limits on llvm's
;; CHECK-NEXT:                                                 __stack_pointer global
;; CHECK-NEXT:
;; CHECK-NEXT:   --string-gathering                            gathers wasm strings to globals
;; CHECK-NEXT:
;; 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-NEXT:                                                 magic imports
;; CHECK-NEXT:
;; 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-NEXT:   --strip                                       deprecated; same as strip-debug
;; CHECK-NEXT:
;; CHECK-NEXT:   --strip-debug                                 strip debug info (including the
;; CHECK-NEXT:                                                 names section)
;; CHECK-NEXT:
;; CHECK-NEXT:   --strip-dwarf                                 strip dwarf debug info
;; CHECK-NEXT:
;; CHECK-NEXT:   --strip-eh                                    strip EH instructions
;; CHECK-NEXT:
;; CHECK-NEXT:   --strip-producers                             strip the wasm producers section
;; CHECK-NEXT:
;; CHECK-NEXT:   --strip-target-features                       strip the wasm target features
;; CHECK-NEXT:                                                 section
;; CHECK-NEXT:
;; CHECK-NEXT:   --stub-unsupported-js                         stub out unsupported JS
;; CHECK-NEXT:                                                 operations
;; CHECK-NEXT:
;; CHECK-NEXT:   --symbolmap                                   (alias for print-function-map)
;; CHECK-NEXT:
;; CHECK-NEXT:   --table64-lowering                            lower 64-bit tables 32-bit ones
;; CHECK-NEXT:
;; 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-NEXT:                                                 exnref
;; CHECK-NEXT:
;; 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-NEXT:   --tuple-optimization                          optimize trivial tuples away
;; CHECK-NEXT:
;; CHECK-NEXT:   --type-finalizing                             mark all leaf types as final
;; CHECK-NEXT:
;; 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-ssa                                    create new nominal types to help
;; CHECK-NEXT:                                                 other optimizations
;; CHECK-NEXT:
;; CHECK-NEXT:   --type-unfinalizing                           mark all types as non-final
;; CHECK-NEXT:                                                 (open)
;; CHECK-NEXT:
;; CHECK-NEXT:   --unsubtyping                                 removes unnecessary subtyping
;; CHECK-NEXT:                                                 relationships
;; CHECK-NEXT:
;; CHECK-NEXT:   --untee                                       removes local.tees, replacing
;; CHECK-NEXT:                                                 them with sets and gets
;; CHECK-NEXT:
;; CHECK-NEXT:   --vacuum                                      removes obviously unneeded code
;; CHECK-NEXT:
;; CHECK-NEXT:
;; CHECK-NEXT: Optimization options:
;; CHECK-NEXT: ---------------------
;; CHECK-NEXT:
;; CHECK-NEXT:    -O                                           execute default optimization
;; CHECK-NEXT:                                                 passes (equivalent to -Os)
;; CHECK-NEXT:
;; CHECK-NEXT:    -O0                                          execute no optimization passes
;; CHECK-NEXT:
;; 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-NEXT:                                                 perf)
;; CHECK-NEXT:
;; 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-NEXT:                                                 take a lot more time and memory,
;; CHECK-NEXT:                                                 but is useful on more nested /
;; CHECK-NEXT:                                                 complex / less-optimized input)
;; CHECK-NEXT:
;; 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-NEXT:                                                 size
;; CHECK-NEXT:
;; 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-NEXT:                                                 code size
;; CHECK-NEXT:
;; 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-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-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-NEXT:                                                 all such functions are inlined)
;; CHECK-NEXT:
;; CHECK-NEXT:   --inline-functions-with-loops,-ifwl           Allow inlining functions with
;; CHECK-NEXT:                                                 loops
;; CHECK-NEXT:
;; 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:                                                 0)
;; CHECK-NEXT:
;; 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-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-NEXT:                                                 application
;; CHECK-NEXT:
;; 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:                                                 will be zero-initialized
;; CHECK-NEXT:
;; CHECK-NEXT:   --skip-pass,-sp                               Skip a pass (do not run it)
;; CHECK-NEXT:
;; CHECK-NEXT:
;; CHECK-NEXT: Tool options:
;; CHECK-NEXT: -------------
;; CHECK-NEXT:
;; CHECK-NEXT:   --mvp-features,-mvp                           Disable all non-MVP features
;; CHECK-NEXT:
;; CHECK-NEXT:   --all-features,-all                           Enable all features
;; CHECK-NEXT:
;; CHECK-NEXT:   --detect-features                             (deprecated - this flag does
;; CHECK-NEXT:                                                 nothing)
;; CHECK-NEXT:
;; CHECK-NEXT:   --quiet,-q                                    Emit less verbose output and
;; CHECK-NEXT:                                                 hide trivial warnings.
;; CHECK-NEXT:
;; CHECK-NEXT:   --experimental-poppy                          Parse wast files as Poppy IR for
;; CHECK-NEXT:                                                 testing purposes.
;; CHECK-NEXT:
;; CHECK-NEXT:   --enable-sign-ext                             Enable sign extension operations
;; CHECK-NEXT:
;; CHECK-NEXT:   --disable-sign-ext                            Disable sign extension
;; CHECK-NEXT:                                                 operations
;; CHECK-NEXT:
;; CHECK-NEXT:   --enable-threads                              Enable atomic operations
;; CHECK-NEXT:
;; CHECK-NEXT:   --disable-threads                             Disable atomic operations
;; CHECK-NEXT:
;; CHECK-NEXT:   --enable-mutable-globals                      Enable mutable globals
;; CHECK-NEXT:
;; CHECK-NEXT:   --disable-mutable-globals                     Disable mutable globals
;; CHECK-NEXT:
;; 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-NEXT:                                                 operations
;; CHECK-NEXT:
;; CHECK-NEXT:   --enable-simd                                 Enable SIMD operations and types
;; CHECK-NEXT:
;; CHECK-NEXT:   --disable-simd                                Disable SIMD operations and
;; CHECK-NEXT:                                                 types
;; CHECK-NEXT:
;; CHECK-NEXT:   --enable-bulk-memory                          Enable bulk memory operations
;; CHECK-NEXT:
;; CHECK-NEXT:   --disable-bulk-memory                         Disable bulk memory operations
;; CHECK-NEXT:
;; CHECK-NEXT:   --enable-exception-handling                   Enable exception handling
;; CHECK-NEXT:                                                 operations
;; CHECK-NEXT:
;; CHECK-NEXT:   --disable-exception-handling                  Disable exception handling
;; CHECK-NEXT:                                                 operations
;; CHECK-NEXT:
;; CHECK-NEXT:   --enable-tail-call                            Enable tail call operations
;; CHECK-NEXT:
;; CHECK-NEXT:   --disable-tail-call                           Disable tail call operations
;; CHECK-NEXT:
;; CHECK-NEXT:   --enable-reference-types                      Enable reference types
;; CHECK-NEXT:
;; CHECK-NEXT:   --disable-reference-types                     Disable reference types
;; CHECK-NEXT:
;; CHECK-NEXT:   --enable-multivalue                           Enable multivalue functions
;; CHECK-NEXT:
;; CHECK-NEXT:   --disable-multivalue                          Disable multivalue functions
;; CHECK-NEXT:
;; CHECK-NEXT:   --enable-gc                                   Enable garbage collection
;; CHECK-NEXT:
;; CHECK-NEXT:   --disable-gc                                  Disable garbage collection
;; CHECK-NEXT:
;; CHECK-NEXT:   --enable-memory64                             Enable memory64
;; CHECK-NEXT:
;; CHECK-NEXT:   --disable-memory64                            Disable memory64
;; CHECK-NEXT:
;; CHECK-NEXT:   --enable-relaxed-simd                         Enable relaxed SIMD
;; CHECK-NEXT:
;; CHECK-NEXT:   --disable-relaxed-simd                        Disable relaxed SIMD
;; CHECK-NEXT:
;; CHECK-NEXT:   --enable-extended-const                       Enable extended const
;; CHECK-NEXT:                                                 expressions
;; CHECK-NEXT:
;; CHECK-NEXT:   --disable-extended-const                      Disable extended const
;; CHECK-NEXT:                                                 expressions
;; CHECK-NEXT:
;; CHECK-NEXT:   --enable-strings                              Enable strings
;; CHECK-NEXT:
;; CHECK-NEXT:   --disable-strings                             Disable strings
;; CHECK-NEXT:
;; CHECK-NEXT:   --enable-multimemory                          Enable multimemory
;; CHECK-NEXT:
;; CHECK-NEXT:   --disable-multimemory                         Disable multimemory
;; CHECK-NEXT:
;; CHECK-NEXT:   --enable-typed-continuations                  Enable typed continuations
;; CHECK-NEXT:
;; CHECK-NEXT:   --disable-typed-continuations                 Disable typed continuations
;; CHECK-NEXT:
;; CHECK-NEXT:   --enable-shared-everything                    Enable shared-everything threads
;; CHECK-NEXT:
;; CHECK-NEXT:   --disable-shared-everything                   Disable shared-everything
;; CHECK-NEXT:                                                 threads
;; CHECK-NEXT:
;; CHECK-NEXT:   --enable-fp16                                 Enable float 16 operations
;; CHECK-NEXT:
;; CHECK-NEXT:   --disable-fp16                                Disable float 16 operations
;; CHECK-NEXT:
;; CHECK-NEXT:   --enable-typed-function-references            Deprecated compatibility flag
;; CHECK-NEXT:
;; CHECK-NEXT:   --disable-typed-function-references           Deprecated compatibility flag
;; CHECK-NEXT:
;; 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-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:                                                 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-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:                                                 contents or call them.
;; CHECK-NEXT:
;; CHECK-NEXT:   --preserve-type-order                         Preserve the order of types from
;; CHECK-NEXT:                                                 the input (useful for debugging
;; CHECK-NEXT:                                                 and testing)
;; CHECK-NEXT:
;; CHECK-NEXT:   --generate-stack-ir                           generate StackIR during writing
;; CHECK-NEXT:
;; CHECK-NEXT:   --optimize-stack-ir                           optimize StackIR during writing
;; CHECK-NEXT:
;; CHECK-NEXT:   --print-stack-ir                              print StackIR during writing
;; CHECK-NEXT:
;; CHECK-NEXT:   --no-stack-ir                                 do not use StackIR (even when it
;; CHECK-NEXT:                                                 is the default)
;; CHECK-NEXT:
;; CHECK-NEXT:
;; CHECK-NEXT: General options:
;; CHECK-NEXT: ----------------
;; CHECK-NEXT:
;; CHECK-NEXT:   --version                                     Output version information and
;; CHECK-NEXT:                                                 exit
;; CHECK-NEXT:
;; CHECK-NEXT:   --help,-h                                     Show this help message and exit
;; CHECK-NEXT:
;; CHECK-NEXT:   --debug,-d                                    Print debug information to
;; CHECK-NEXT:                                                 stderr
;; CHECK-NEXT:
