Lit tests for tool help messages (#3965)

Add list tests for the help messages of all tools, factoring out common options
into shared tests. This is slightly brittle because the text wrapping depends on
the length of the longest option, but that brittleness should be worth the
benefit of being able to see the actual help text in the tests.

12 files changed, 1089 insertions, 0 deletions

diff --git a/test/lit/help/optimization-opts.test b/test/lit/help/optimization-opts.test
new file mode 100644
index 000000000..3350015a1
--- /dev/null
+++ b/test/lit/help/optimization-opts.test
@@ -0,0 +1,491 @@
+;; RUN: wasm-opt --help | filecheck %s
+;; RUN: wasm2js --help | filecheck %s
+
+;; CHECK:      Options:
+;; 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:
+;; 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-typed-function-references            Enable typed function references
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --disable-typed-function-references           Disable typed function
+;; CHECK-NEXT:                                                 references
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --enable-gc-nn-locals                         Enable GC non-null locals
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --disable-gc-nn-locals                        Disable GC non-null locals
+;; 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:
+;; CHECK-NEXT:   --nominal                                     Use the prototype nominal type
+;; CHECK-NEXT:                                                 system instead of the normal
+;; CHECK-NEXT:                                                 equirecursive type system.
+;; CHECK-NEXT:
+;; CHECK-NEXT:    -O                                           execute default optimization
+;; CHECK-NEXT:                                                 passes
+;; 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:   --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:   --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:   --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:   --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:   --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-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:   --generate-stack-ir                           generate Stack IR
+;; 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:   --legalize-js-interface                       legalizes i64 types on the
+;; CHECK-NEXT:                                                 import/export boundary
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --legalize-js-interface-minimally             legalizes i64 types on the
+;; CHECK-NEXT:                                                 import/export boundary in a
+;; CHECK-NEXT:                                                 minimal manner, only on things
+;; CHECK-NEXT:                                                 only JS will call
+;; 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:   --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-locals                                merges locals when beneficial
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --metrics                                     reports metrics
+;; 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:   --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:   --name-types                                  (re)name all heap types
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --nm                                          name list
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --no-exit-runtime                             removes calls to atexit(), which
+;; CHECK-NEXT:                                                 is valid if the C runtime will
+;; CHECK-NEXT:                                                 never be exited
+;; 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-instructions                       optimizes instruction
+;; CHECK-NEXT:                                                 combinations
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --optimize-stack-ir                           optimize Stack IR
+;; 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:   --print-stack-ir                              print out Stack IR (useful for
+;; CHECK-NEXT:                                                 internal debugging)
+;; 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:   --reorder-functions                           sorts functions 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:   --set-globals                                 sets specified globals to
+;; CHECK-NEXT:                                                 specified values
+;; 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:   --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:   --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-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:   --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:   --untee                                       removes local.tees, replacing
+;; CHECK-NEXT:                                                 them with sets and gets
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --vacuum                                      removes obviously unneeded code
diff --git a/test/lit/help/tool-opts.test b/test/lit/help/tool-opts.test
new file mode 100644
index 000000000..2d3007779
--- /dev/null
+++ b/test/lit/help/tool-opts.test
@@ -0,0 +1,86 @@
+;; RUN: wasm-as --help | filecheck %s
+;; RUN: wasm-ctor-eval --help | filecheck %s
+;; RUN: wasm-dis --help | filecheck %s
+;; RUN: wasm-emscripten-finalize --help | filecheck %s
+;; RUN: wasm-metadce --help | filecheck %s
+;; RUN: wasm-split --help | filecheck %s
+
+wasm-as INFILE
+
+;; CHECK:      Options:
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --version                            Output version information and exit
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --help,-h                            Show this help message and exit
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --debug,-d                           Print debug information to stderr
+;; 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 nothing)
+;; CHECK-NEXT:
+;; 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-NEXT:                                        purposes.
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --enable-sign-ext                    Enable sign extension operations
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --disable-sign-ext                   Disable sign extension 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 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 operations
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --disable-exception-handling         Disable exception handling 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-typed-function-references   Enable typed function references
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --disable-typed-function-references  Disable typed function references
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --enable-gc-nn-locals                Enable GC non-null locals
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --disable-gc-nn-locals               Disable GC non-null locals
diff --git a/test/lit/help/wasm-as.test b/test/lit/help/wasm-as.test
new file mode 100644
index 000000000..4bf8f4494
--- /dev/null
+++ b/test/lit/help/wasm-as.test
@@ -0,0 +1,31 @@
+;; RUN: wasm-as --help | filecheck %s
+
+;; CHECK:      wasm-as INFILE
+;; CHECK-NEXT:
+;; CHECK-NEXT: Assemble a .wat (WebAssembly text format) into a .wasm (WebAssembly binary
+;; CHECK-NEXT: format)
+
+;; Skip standard tool options
+
+;; CHECK:        --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
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --nominal                            Use the prototype nominal type system
+;; CHECK-NEXT:                                        instead of the normal equirecursive type
+;; CHECK-NEXT:                                        system.
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --output,-o                          Output file (stdout if not specified)
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --validate,-v                        Control validation of the output module
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --debuginfo,-g                       Emit names section and debug info
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --source-map,-sm                     Emit source map to the specified file
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --source-map-url,-su                 Use specified string as source map URL
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --symbolmap,-s                       Emit a symbol map (indexes => names)
diff --git a/test/lit/help/wasm-ctor-eval.test b/test/lit/help/wasm-ctor-eval.test
new file mode 100644
index 000000000..da10f098a
--- /dev/null
+++ b/test/lit/help/wasm-ctor-eval.test
@@ -0,0 +1,29 @@
+;; RUN: wasm-ctor-eval --help | filecheck %s
+
+;; CHECK:      wasm-ctor-eval INFILE
+;; CHECK-NEXT:
+;; CHECK-NEXT: Execute C++ global constructors ahead of time
+;; CHECK-NEXT:
+
+;; Skip standard tool options
+
+;; CHECK:        --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
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --nominal                            Use the prototype nominal type system
+;; CHECK-NEXT:                                        instead of the normal equirecursive type
+;; CHECK-NEXT:                                        system.
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --output,-o                          Output file (stdout if not specified)
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --emit-text,-S                       Emit text instead of binary for the
+;; CHECK-NEXT:                                        output file
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --debuginfo,-g                       Emit names section and debug info
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --ctors,-c                           Comma-separated list of global
+;; CHECK-NEXT:                                        constructor functions to evaluate
diff --git a/test/lit/help/wasm-dis.test b/test/lit/help/wasm-dis.test
new file mode 100644
index 000000000..47fcc4e2f
--- /dev/null
+++ b/test/lit/help/wasm-dis.test
@@ -0,0 +1,25 @@
+;; RUN: wasm-dis --help | filecheck %s
+
+;; CHECK:      wasm-dis INFILE
+;; CHECK-NEXT:
+;; CHECK-NEXT: Un-assemble a .wasm (WebAssembly binary format) into a .wat (WebAssembly text
+;; CHECK-NEXT: format)
+;; CHECK-NEXT:
+
+;; Skip standard tool options
+
+;; CHECK:        --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
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --nominal                            Use the prototype nominal type system
+;; CHECK-NEXT:                                        instead of the normal equirecursive type
+;; CHECK-NEXT:                                        system.
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --output,-o                          Output file (stdout if not specified)
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --source-map,-sm                     Consume source map from the specified
+;; CHECK-NEXT:                                        file to add location information
diff --git a/test/lit/help/wasm-emscripten-finalize.test b/test/lit/help/wasm-emscripten-finalize.test
new file mode 100644
index 000000000..52a5ba701
--- /dev/null
+++ b/test/lit/help/wasm-emscripten-finalize.test
@@ -0,0 +1,77 @@
+;; RUN: wasm-emscripten-finalize --help | filecheck %s
+
+;; CHECK-NEXT: wasm-emscripten-finalize INFILE
+;; CHECK-NEXT:
+;; CHECK-NEXT: Performs Emscripten-specific transforms on .wasm files
+;; CHECK-NEXT:
+
+;; Skip standard tool options
+
+;; CHECK:        --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
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --nominal                            Use the prototype nominal type system
+;; CHECK-NEXT:                                        instead of the normal equirecursive type
+;; CHECK-NEXT:                                        system.
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --output,-o                          Output file
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --debuginfo,-g                       Emit names section in wasm binary (or
+;; CHECK-NEXT:                                        full debuginfo in wast)
+;; CHECK-NEXT:
+;; 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-NEXT:                                        file is specified, we write to stdout.
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --global-base                        The address at which static globals were
+;; CHECK-NEXT:                                        placed
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --initial-stack-pointer              ignored - will be removed in a future
+;; CHECK-NEXT:                                        release
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --side-module                        Input is an emscripten side module
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --new-pic-abi                        Use new/llvm PIC abi
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --input-source-map,-ism              Consume source map from the specified
+;; CHECK-NEXT:                                        file
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --no-legalize-javascript-ffi,-nj     Do not fully legalize (i64->i32,
+;; CHECK-NEXT:                                        f32->f64) the imports and exports for
+;; CHECK-NEXT:                                        interfacing with JS
+;; 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-NEXT:                                        legalization of dynCalls)
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --output-source-map,-osm             Emit source map to the specified file
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --output-source-map-url,-osu         Emit specified string as source map URL
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --separate-data-segments             Separate data segments to a file
+;; CHECK-NEXT:
+;; 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-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-NEXT:                                        reduce the number of changes to the wasm,
+;; 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
diff --git a/test/lit/help/wasm-metadce.test b/test/lit/help/wasm-metadce.test
new file mode 100644
index 000000000..1a8255346
--- /dev/null
+++ b/test/lit/help/wasm-metadce.test
@@ -0,0 +1,73 @@
+;; RUN: wasm-metadce --help | filecheck %s
+
+;; CHECK:      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-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-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-NEXT: describing the things in the rest of the graph that can be eliminated as well.
+;; CHECK-NEXT:
+;; 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: single-quotes, etc. are not supported):
+;; CHECK-NEXT:
+;; CHECK-NEXT:   [
+;; CHECK-NEXT:     {
+;; CHECK-NEXT:       "name": "entity1",
+;; CHECK-NEXT:       "reaches": ["entity2, "entity3"],
+;; CHECK-NEXT:       "root": true
+;; CHECK-NEXT:     },
+;; CHECK-NEXT:     {
+;; CHECK-NEXT:       "name": "entity2",
+;; CHECK-NEXT:       "reaches": ["entity1, "entity4"]
+;; CHECK-NEXT:     },
+;; CHECK-NEXT:     {
+;; CHECK-NEXT:       "name": "entity3",
+;; CHECK-NEXT:       "reaches": ["entity1"],
+;; CHECK-NEXT:       "export": "export1"
+;; CHECK-NEXT:     },
+;; CHECK-NEXT:     {
+;; CHECK-NEXT:       "name": "entity4",
+;; CHECK-NEXT:       "import": ["module", "import1"]
+;; CHECK-NEXT:     },
+;; CHECK-NEXT:   ]
+;; CHECK-NEXT:
+;; 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: roots.
+;; CHECK-NEXT:
+
+;; Skip standard tool options
+
+;; CHECK:        --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
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --nominal                            Use the prototype nominal type system
+;; CHECK-NEXT:                                        instead of the normal equirecursive type
+;; CHECK-NEXT:                                        system.
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --output,-o                          Output file (stdout if not specified)
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --emit-text,-S                       Emit text instead of binary for the
+;; CHECK-NEXT:                                        output file
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --debuginfo,-g                       Emit names section and debug info
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --graph-file,-f                      Filename of the graph description file
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --dump,-d                            Dump the combined graph file (useful for
+;; CHECK-NEXT:                                        debugging)
diff --git a/test/lit/help/wasm-opt.test b/test/lit/help/wasm-opt.test
new file mode 100644
index 000000000..7d2d42cf1
--- /dev/null
+++ b/test/lit/help/wasm-opt.test
@@ -0,0 +1,76 @@
+;; RUN: wasm-opt --help | filecheck %s
+
+;; CHECK-NEXT: wasm-opt INFILE
+;; CHECK-NEXT:
+;; CHECK-NEXT: Read, write, and optimize files
+;; CHECK-NEXT:
+;; CHECK-NEXT: Options:
+
+;; Skip standard optimization options
+
+;; CHECK:        --output,-o                                   Output file (stdout if not
+;; CHECK-NEXT:                                                 specified)
+;; CHECK-NEXT:
+;; 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-NEXT:                                                 decreases
+;; CHECK-NEXT:
+;; 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-NEXT:                                                 fuzzing find bugs
+;; 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-NEXT:                                                 compared between the two, and an
+;; CHECK-NEXT:                                                 error occurs if they are not
+;; CHECK-NEXT:                                                 equal
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --translate-to-fuzz,-ttf                      Translate the input into a valid
+;; CHECK-NEXT:                                                 wasm module *somehow*, useful
+;; CHECK-NEXT:                                                 for fuzzing
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --initial-fuzz,-if                            Initial wasm content in
+;; CHECK-NEXT:                                                 translate-to-fuzz (-ttf) mode
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --fuzz-passes,-fp                             Pick a random set of passes to
+;; CHECK-NEXT:                                                 run, useful for fuzzing. this
+;; CHECK-NEXT:                                                 depends on translate-to-fuzz (it
+;; CHECK-NEXT:                                                 picks the passes from the input)
+;; CHECK-NEXT:
+;; 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-NEXT:                                                 loads/stores/indirect calls when
+;; CHECK-NEXT:                                                 fuzzing
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --emit-js-wrapper,-ejw                        Emit a JavaScript wrapper file
+;; CHECK-NEXT:                                                 that can run the wasm with some
+;; CHECK-NEXT:                                                 test values, useful for fuzzing
+;; 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-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-NEXT:                                                 compiled with wasm2c, useful for
+;; CHECK-NEXT:                                                 fuzzing
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --input-source-map,-ism                       Consume source map from the
+;; CHECK-NEXT:                                                 specified file
+;; CHECK-NEXT:
+;; 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-NEXT:                                                 map URL
diff --git a/test/lit/help/wasm-reduce.test b/test/lit/help/wasm-reduce.test
new file mode 100644
index 000000000..b3f3ac710
--- /dev/null
+++ b/test/lit/help/wasm-reduce.test
@@ -0,0 +1,47 @@
+;; RUN: wasm-reduce --help | filecheck %s
+
+;; CHECK:      wasm-reduce INFILE
+;; CHECK-NEXT:
+;; CHECK-NEXT: Reduce a wasm file to a smaller one that has the same behavior on a given
+;; CHECK-NEXT: command
+;; CHECK-NEXT:
+;; CHECK-NEXT: Options:
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --version         Output version information and exit
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --help,-h         Show this help message and exit
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --debug,-d        Print debug information to stderr
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --command,-cmd    The command to run on the test, that we want to reduce while
+;; CHECK-NEXT:                     keeping the command's output identical. We look at the
+;; CHECK-NEXT:                     command's return code and stdout here (TODO: stderr), and we
+;; CHECK-NEXT:                     reduce while keeping those unchanged.
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --test,-t         Test file (this will be written to to test, the given
+;; CHECK-NEXT:                     command should read it when we call it)
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --working,-w      Working file (this will contain the current good state while
+;; CHECK-NEXT:                     doing temporary computations, and will contain the final
+;; CHECK-NEXT:                     best result at the end)
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --binaries,-b     binaryen binaries location (bin/ directory)
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --text,-S         Emit intermediate files as text, instead of binary (also
+;; CHECK-NEXT:                     make sure the test and working files have a .wat or .wast
+;; CHECK-NEXT:                     suffix)
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --denan           Avoid nans when reducing
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --verbose,-v      Verbose output mode
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --debugInfo,-g    Keep debug info in binaries
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --force,-f        Force the reduction attempt, ignoring problems that imply it
+;; CHECK-NEXT:                     is unlikely to succeed
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --timeout,-to     A timeout to apply to each execution of the command, in
+;; CHECK-NEXT:                     seconds (default: 2)
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --extra-flags,-ef Extra commandline flags to pass to wasm-opt while reducing.
+;; CHECK-NEXT:                     (default: --enable-all)
diff --git a/test/lit/help/wasm-shell.test b/test/lit/help/wasm-shell.test
new file mode 100644
index 000000000..c171e1428
--- /dev/null
+++ b/test/lit/help/wasm-shell.test
@@ -0,0 +1,17 @@
+;; RUN: wasm-shell --help | filecheck %s
+
+wasm-shell INFILE
+
+;; CHECK:      Execute .wast files
+;; CHECK-NEXT:
+;; CHECK-NEXT: Options:
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --version  Output version information and exit
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --help,-h  Show this help message and exit
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --debug,-d Print debug information to stderr
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --entry,-e Call the entry point after parsing the module
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --skip,-s  Skip input on certain lines (comma-separated-list)
diff --git a/test/lit/help/wasm-split.test b/test/lit/help/wasm-split.test
new file mode 100644
index 000000000..28f079d2f
--- /dev/null
+++ b/test/lit/help/wasm-split.test
@@ -0,0 +1,101 @@
+;; RUN: wasm-split --help | filecheck %s
+
+;; 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-NEXT: profiles. Options that are only accepted in particular modes are marked with the
+;; CHECK-NEXT: accepted "[<modes>]" in their descriptions.
+;; CHECK-NEXT:
+
+;; Skip standard tool options
+
+;; CHECK:        --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
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --nominal                            Use the prototype nominal type system
+;; CHECK-NEXT:                                        instead of the normal equirecursive type
+;; CHECK-NEXT:                                        system.
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --split                              Split an input module into two output
+;; CHECK-NEXT:                                        modules. The default mode.
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --instrument                         Instrument an input module to allow it 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-NEXT:                                        module into a single profile.
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --profile                            [split] The profile to use to guide
+;; CHECK-NEXT:                                        splitting.
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --keep-funcs                         [split] Comma-separated list of functions
+;; CHECK-NEXT:                                        to keep in the primary module, regardless
+;; CHECK-NEXT:                                        of any profile.
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --split-funcs                        [split] Comma-separated list of functions
+;; CHECK-NEXT:                                        to split into the secondary module,
+;; CHECK-NEXT:                                        regardless of any profile. If there is no
+;; CHECK-NEXT:                                        profile, then this defaults to all
+;; CHECK-NEXT:                                        functions defined in the module.
+;; CHECK-NEXT:
+;; 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-NEXT:                                        module.
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --symbolmap                          [split] Write a symbol map file for each
+;; CHECK-NEXT:                                        of the output modules.
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --placeholdermap                     [split] Write a file mapping placeholder
+;; CHECK-NEXT:                                        indices to the function names.
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --import-namespace                   [split] The namespace from which to
+;; CHECK-NEXT:                                        import objects from the primary module
+;; CHECK-NEXT:                                        into the secondary module.
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --placeholder-namespace              [split] The namespace from which to
+;; CHECK-NEXT:                                        import placeholder functions into the
+;; CHECK-NEXT:                                        primary module.
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --export-prefix                      [split] An identifying prefix to prepend
+;; CHECK-NEXT:                                        to new export names created by module
+;; CHECK-NEXT:                                        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-NEXT:                                        `__write_profile`.
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --emit-module-names                  [split, instrument] Emit module names,
+;; CHECK-NEXT:                                        even if not emitting the rest of the
+;; CHECK-NEXT:                                        names section. Can help differentiate the
+;; CHECK-NEXT:                                        modules in stack traces. This option will
+;; CHECK-NEXT:                                        be removed once simpler ways of naming
+;; CHECK-NEXT:                                        modules are widely available. See
+;; CHECK-NEXT:                                        https://bugs.chromium.org/p/v8/issues/detail?id=11808.
+;; 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-NEXT:                                        for that use case and remove this.
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --emit-text,-S                       [split, instrument] Emit text instead of
+;; CHECK-NEXT:                                        binary for the output file or files.
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --debuginfo,-g                       [split, instrument] Emit names section in
+;; CHECK-NEXT:                                        wasm binary (or full debuginfo in wast)
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --output,-o                          [instrument, merge-profiles] Output file.
+;; CHECK-NEXT:
+;; CHECK-NEXT:   --verbose,-v                         Verbose output mode. Prints the functions
+;; CHECK-NEXT:                                        that will be kept and split out when
+;; CHECK-NEXT:                                        splitting a module.
diff --git a/test/lit/help/wasm2js.test b/test/lit/help/wasm2js.test
new file mode 100644
index 000000000..b326bd77b
--- /dev/null
+++ b/test/lit/help/wasm2js.test
@@ -0,0 +1,36 @@
+;; RUN: wasm2js --help | filecheck %s
+
+;; CHECK:      wasm2js INFILE
+;; CHECK-NEXT:
+;; CHECK-NEXT: Transform .wasm/.wat files to asm.js
+
+;; Skip standard tool options
+
+;; CHECK:        --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