blob: 84b5049ddcc692e2090718260e36a1d756c4b211 [file] [log] [blame]
;; RUN: wasm-opt --help | filecheck %s
;; CHECK: ================================================================================
;; CHECK-NEXT: wasm-opt INFILE
;; CHECK-NEXT:
;; CHECK-NEXT: Read, write, and optimize files
;; CHECK-NEXT: ================================================================================
;; CHECK-NEXT:
;; CHECK-NEXT:
;; CHECK-NEXT: wasm-opt options:
;; CHECK-NEXT: -----------------
;; CHECK-NEXT:
;; CHECK-NEXT: --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-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
;; CHECK-NEXT:
;; CHECK-NEXT: --new-wat-parser Use the experimental new WAT
;; CHECK-NEXT: parser
;; CHECK-NEXT:
;; CHECK-NEXT: --experimental-new-eh After running all requested
;; CHECK-NEXT: transformations / optimizations,
;; CHECK-NEXT: translate the instruction to use
;; CHECK-NEXT: the new EH instructions at the
;; CHECK-NEXT: end. Depending on the
;; CHECK-NEXT: optimization level specified,
;; CHECK-NEXT: this may do some more
;; CHECK-NEXT: post-translation optimizations.
;; 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: --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: --generate-stack-ir generate Stack IR
;; 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: --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-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
;; 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: --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: --optimize-stack-ir optimize Stack IR
;; 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: --print-stack-ir print out Stack IR (useful for
;; CHECK-NEXT: internal debugging)
;; 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: --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: --translate-to-new-eh translate old EH instructions to
;; CHECK-NEXT: new ones
;; 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-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:
;; 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:
;; 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: