| ;; RUN: wasm-opt --help | filecheck %s | |
| ;; CHECK: ================================================================================ | |
| ;; CHECK-NEXT: wasm-opt INFILE | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: Read, write, and optimize files. | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: Example usage: | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: wasm-opt input.wasm -O3 -o output.wasm | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: This reads an input wasm file, optimizes with -O3, and writes out the result. | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: For more on how to optimize effectively, see | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: https://github.com/WebAssembly/binaryen/wiki/Optimizer-Cookbook | |
| ;; CHECK-NEXT: https://github.com/WebAssembly/binaryen/wiki/GC-Optimization-Guidebook | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: ================================================================================ | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: wasm-opt options: | |
| ;; CHECK-NEXT: ----------------- | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --output,-o Output file | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --emit-text,-S Emit text instead of binary for | |
| ;; CHECK-NEXT: the output file | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --converge,-c Run passes to convergence, | |
| ;; CHECK-NEXT: continuing while binary size | |
| ;; CHECK-NEXT: decreases | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --fuzz-exec-before,-feh Execute functions before | |
| ;; CHECK-NEXT: optimization, helping fuzzing | |
| ;; CHECK-NEXT: find bugs | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --fuzz-exec,-fe Execute functions before and | |
| ;; CHECK-NEXT: after optimization, helping | |
| ;; CHECK-NEXT: fuzzing find bugs | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --fuzz-exec-second A second module to link with the | |
| ;; CHECK-NEXT: first, for fuzz-exec-before | |
| ;; CHECK-NEXT: (only before, as optimizations | |
| ;; CHECK-NEXT: are not applied to it) | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --extra-fuzz-command,-efc An extra command to run on the | |
| ;; CHECK-NEXT: output before and after | |
| ;; CHECK-NEXT: optimizing. The output is | |
| ;; CHECK-NEXT: compared between the two, and an | |
| ;; CHECK-NEXT: error occurs if they are not | |
| ;; CHECK-NEXT: equal | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --translate-to-fuzz,-ttf Translate the input into a valid | |
| ;; CHECK-NEXT: wasm module *somehow*, useful | |
| ;; CHECK-NEXT: for fuzzing | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --initial-fuzz,-if Initial wasm content in | |
| ;; CHECK-NEXT: translate-to-fuzz (-ttf) mode | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --fuzz-passes,-fp When doing translate-to-fuzz, | |
| ;; CHECK-NEXT: pick a set of random passes from | |
| ;; CHECK-NEXT: the input to further shape the | |
| ;; CHECK-NEXT: wasm | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --no-fuzz-memory don't emit memory ops when | |
| ;; CHECK-NEXT: fuzzing | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --no-fuzz-oob don't emit out-of-bounds | |
| ;; CHECK-NEXT: loads/stores/indirect calls when | |
| ;; CHECK-NEXT: fuzzing | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --fuzz-preserve-imports-exports don't add imports and exports in | |
| ;; CHECK-NEXT: -ttf mode, and keep the start | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --fuzz-against-js modify the wasm in valid ways | |
| ;; CHECK-NEXT: that assume it is used only from | |
| ;; CHECK-NEXT: JS | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --fuzz-import a module to use as an import in | |
| ;; CHECK-NEXT: -ttf mode | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --emit-spec-wrapper,-esw Emit a wasm spec interpreter | |
| ;; CHECK-NEXT: wrapper file that can run the | |
| ;; CHECK-NEXT: wasm with some test values, | |
| ;; CHECK-NEXT: useful for fuzzing | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --emit-wasm2c-wrapper,-esw Emit a C wrapper file that can | |
| ;; CHECK-NEXT: run the wasm after it is | |
| ;; CHECK-NEXT: compiled with wasm2c, useful for | |
| ;; CHECK-NEXT: fuzzing | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --input-source-map,-ism Consume source map from the | |
| ;; CHECK-NEXT: specified file | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --output-source-map,-osm Emit source map to the specified | |
| ;; CHECK-NEXT: file | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --output-source-map-url,-osu Emit specified string as source | |
| ;; CHECK-NEXT: map URL | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --experimental-new-eh Deprecated; same as | |
| ;; CHECK-NEXT: --emit-exnref | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --emit-exnref After running all requested | |
| ;; CHECK-NEXT: transformations / optimizations, | |
| ;; CHECK-NEXT: translate the instruction to use | |
| ;; CHECK-NEXT: the new EH instructions at the | |
| ;; CHECK-NEXT: end. Depending on the | |
| ;; CHECK-NEXT: optimization level specified, | |
| ;; CHECK-NEXT: this may do some more | |
| ;; CHECK-NEXT: post-translation optimizations. | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: Optimization passes: | |
| ;; CHECK-NEXT: -------------------- | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --abstract-type-refining refine and merge abstract | |
| ;; CHECK-NEXT: (never-created) types | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --alignment-lowering lower unaligned loads and stores | |
| ;; CHECK-NEXT: to smaller aligned ones | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --asyncify async/await style transform, | |
| ;; CHECK-NEXT: allowing pausing and resuming | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --avoid-reinterprets Tries to avoid reinterpret | |
| ;; CHECK-NEXT: operations via more loads | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --cfp propagate constant struct field | |
| ;; CHECK-NEXT: values | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --cfp-reftest propagate constant struct field | |
| ;; CHECK-NEXT: values, using ref.test | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --coalesce-locals reduce # of locals by coalescing | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --coalesce-locals-learning reduce # of locals by coalescing | |
| ;; CHECK-NEXT: and learning | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --code-folding fold code, merging duplicates | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --code-pushing push code forward, potentially | |
| ;; CHECK-NEXT: making it not always execute | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --const-hoisting hoist repeated constants to a | |
| ;; CHECK-NEXT: local | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --constraint-analysis finds and uses mathematical | |
| ;; CHECK-NEXT: constraints on locals | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --dae removes arguments to calls in an | |
| ;; CHECK-NEXT: lto-like manner | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --dae-optimizing removes arguments to calls in an | |
| ;; CHECK-NEXT: lto-like manner, and optimizes | |
| ;; CHECK-NEXT: where we removed | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --dae2 Experimental reimplementation of | |
| ;; CHECK-NEXT: DAE | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --dce removes unreachable code | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --dealign forces all loads and stores to | |
| ;; CHECK-NEXT: have alignment 1 | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --denan instrument the wasm to convert | |
| ;; CHECK-NEXT: NaNs into 0 at runtime | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --dfo optimizes using the DataFlow SSA | |
| ;; CHECK-NEXT: IR | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --directize turns indirect calls into direct | |
| ;; CHECK-NEXT: ones | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --discard-global-effects discards global effect info | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --duplicate-function-elimination removes duplicate functions | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --duplicate-import-elimination removes duplicate imports | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --dwarfdump dump DWARF debug info sections | |
| ;; CHECK-NEXT: from the read binary | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --emit-target-features emit the target features section | |
| ;; CHECK-NEXT: in the output | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --enclose-world modify the wasm (destructively) | |
| ;; CHECK-NEXT: for closed-world | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --extract-function leaves just one function (useful | |
| ;; CHECK-NEXT: for debugging) | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --extract-function-index leaves just one function | |
| ;; CHECK-NEXT: selected by index | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --flatten flattens out code, removing | |
| ;; CHECK-NEXT: nesting | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --fpcast-emu emulates function pointer casts, | |
| ;; CHECK-NEXT: allowing incorrect indirect | |
| ;; CHECK-NEXT: calls to (sometimes) work | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --func-metrics reports function metrics | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --generate-dyncalls generate dynCall functions used | |
| ;; CHECK-NEXT: by emscripten ABI | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --generate-global-effects generate global effect info | |
| ;; CHECK-NEXT: (helps later passes) | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --generate-i64-dyncalls generate dynCall functions used | |
| ;; CHECK-NEXT: by emscripten ABI, but only for | |
| ;; CHECK-NEXT: functions with i64 in their | |
| ;; CHECK-NEXT: signature (which cannot be | |
| ;; CHECK-NEXT: invoked via the wasm table | |
| ;; CHECK-NEXT: without JavaScript BigInt | |
| ;; CHECK-NEXT: support). | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --global-refining refine the types of globals | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --gsi globally optimize struct values | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --gsi-desc-cast globally optimize struct values, | |
| ;; CHECK-NEXT: also emitting ref.cast_desc_eq | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --gto globally optimize GC types | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --gufa Grand Unified Flow Analysis: | |
| ;; CHECK-NEXT: optimize the entire program | |
| ;; CHECK-NEXT: using information about what | |
| ;; CHECK-NEXT: content can actually appear in | |
| ;; CHECK-NEXT: each location | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --gufa-cast-all GUFA plus add casts for all | |
| ;; CHECK-NEXT: inferences | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --gufa-optimizing GUFA plus local optimizations in | |
| ;; CHECK-NEXT: functions we modified | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --heap-store-optimization optimize heap (GC) stores | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --heap2local replace GC allocations with | |
| ;; CHECK-NEXT: locals | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --i64-to-i32-lowering lower all uses of i64s to use | |
| ;; CHECK-NEXT: i32s instead | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --inline-main inline __original_main into main | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --inlining inline functions (you probably | |
| ;; CHECK-NEXT: want inlining-optimizing) | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --inlining-optimizing inline functions and optimizes | |
| ;; CHECK-NEXT: where we inlined | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --instrument-branch-hints instrument branch hints so we | |
| ;; CHECK-NEXT: can see which guessed right | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --instrument-locals instrument the build with code | |
| ;; CHECK-NEXT: to intercept all loads and | |
| ;; CHECK-NEXT: stores | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --instrument-memory instrument the build with code | |
| ;; CHECK-NEXT: to intercept all loads and | |
| ;; CHECK-NEXT: stores | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --intrinsic-lowering lower away binaryen intrinsics | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --legalize-and-prune-js-interface legalizes the import/export | |
| ;; CHECK-NEXT: boundary and prunes when needed | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --legalize-js-interface legalizes i64 types on the | |
| ;; CHECK-NEXT: import/export boundary | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --licm loop invariant code motion | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --limit-segments attempt to merge segments to fit | |
| ;; CHECK-NEXT: within web limits | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --llvm-memory-copy-fill-lowering Lower memory.copy and | |
| ;; CHECK-NEXT: memory.fill to wasm mvp and | |
| ;; CHECK-NEXT: disable the bulk-memory feature. | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --llvm-nontrapping-fptoint-lowering lower nontrapping float-to-int | |
| ;; CHECK-NEXT: operations to wasm mvp and | |
| ;; CHECK-NEXT: disable the nontrapping fptoint | |
| ;; CHECK-NEXT: feature | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --local-cse common subexpression elimination | |
| ;; CHECK-NEXT: inside basic blocks | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --local-subtyping apply more specific subtypes to | |
| ;; CHECK-NEXT: locals where possible | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --log-execution instrument the build with | |
| ;; CHECK-NEXT: logging of where execution goes | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --make-shared-objects Make structs and arrays shared | |
| ;; CHECK-NEXT: and functions unshared | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --mark-js-called mark js called functions (using | |
| ;; CHECK-NEXT: configureAll) as doing so | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --memory-packing packs memory into separate | |
| ;; CHECK-NEXT: segments, skipping zeros | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --memory64-lowering lower loads and stores to a | |
| ;; CHECK-NEXT: 64-bit memory to instead use a | |
| ;; CHECK-NEXT: 32-bit one | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --merge-blocks merges blocks to their parents | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --merge-j2cl-itables Merges itable structures into | |
| ;; CHECK-NEXT: vtables to make types more | |
| ;; CHECK-NEXT: compact | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --merge-locals merges locals when beneficial | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --merge-similar-functions merges similar functions when | |
| ;; CHECK-NEXT: beneficial | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --metrics reports metrics (with an | |
| ;; CHECK-NEXT: optional title, | |
| ;; CHECK-NEXT: --metrics[=TITLE]) | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --minify-imports minifies import names (only | |
| ;; CHECK-NEXT: those, and not export names), | |
| ;; CHECK-NEXT: and emits a mapping to the | |
| ;; CHECK-NEXT: minified ones | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --minify-imports-and-exports minifies both import and export | |
| ;; CHECK-NEXT: names, and emits a mapping to | |
| ;; CHECK-NEXT: the minified ones | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --minify-imports-and-exports-and-modules minifies both import and export | |
| ;; CHECK-NEXT: names, and emits a mapping to | |
| ;; CHECK-NEXT: the minified ones, and minifies | |
| ;; CHECK-NEXT: the modules as well | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --minimize-rec-groups Split types into minimal | |
| ;; CHECK-NEXT: recursion groups | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --monomorphize creates specialized versions of | |
| ;; CHECK-NEXT: functions | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --monomorphize-always creates specialized versions of | |
| ;; CHECK-NEXT: functions (even if unhelpful) | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --multi-memory-lowering combines multiple memories into | |
| ;; CHECK-NEXT: a single memory | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --multi-memory-lowering-with-bounds-checks combines multiple memories into | |
| ;; CHECK-NEXT: a single memory, trapping if the | |
| ;; CHECK-NEXT: read or write is larger than the | |
| ;; CHECK-NEXT: length of the memory's data | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --name-types (re)name all heap types | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --nm name list | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --no-full-inline mark functions as no-inline (for | |
| ;; CHECK-NEXT: full inlining only) | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --no-inline mark functions as no-inline | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --no-partial-inline mark functions as no-inline (for | |
| ;; CHECK-NEXT: partial inlining only) | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --once-reduction reduces calls to code that only | |
| ;; CHECK-NEXT: runs once | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --optimize-added-constants optimizes added constants into | |
| ;; CHECK-NEXT: load/store offsets | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --optimize-added-constants-propagate optimizes added constants into | |
| ;; CHECK-NEXT: load/store offsets, propagating | |
| ;; CHECK-NEXT: them across locals too | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --optimize-casts eliminate and reuse casts | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --optimize-for-js early optimize of the | |
| ;; CHECK-NEXT: instruction combinations for js | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --optimize-instructions optimizes instruction | |
| ;; CHECK-NEXT: combinations | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --optimize-j2cl optimizes J2CL specific | |
| ;; CHECK-NEXT: constructs. | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --outlining outline instructions | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --pick-load-signs pick load signs based on their | |
| ;; CHECK-NEXT: uses | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --poppify Transform Binaryen IR into Poppy | |
| ;; CHECK-NEXT: IR | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --post-emscripten miscellaneous optimizations for | |
| ;; CHECK-NEXT: Emscripten-generated code | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --precompute computes compile-time | |
| ;; CHECK-NEXT: evaluatable expressions | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --precompute-propagate computes compile-time | |
| ;; CHECK-NEXT: evaluatable expressions and | |
| ;; CHECK-NEXT: propagates them through locals | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --print print in s-expression format | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --print-boundary print boundary in JSON format | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --print-call-graph print call graph | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --print-features print options for enabled | |
| ;; CHECK-NEXT: features | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --print-full print in full s-expression | |
| ;; CHECK-NEXT: format | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --print-function-map print a map of function indexes | |
| ;; CHECK-NEXT: to names | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --print-minified print in minified s-expression | |
| ;; CHECK-NEXT: format | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --propagate-debug-locs propagate debug location from | |
| ;; CHECK-NEXT: parents or previous siblings to | |
| ;; CHECK-NEXT: child nodes | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --propagate-globals-globally propagate global values to other | |
| ;; CHECK-NEXT: globals (useful for tests) | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --remove-empty-function-exports removes exports of empty | |
| ;; CHECK-NEXT: functions | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --remove-exports removes exports using a wildcard | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --remove-imports removes imports and replaces | |
| ;; CHECK-NEXT: them with nops | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --remove-memory removes memory init (legacy | |
| ;; CHECK-NEXT: name) | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --remove-memory-init removes memory initialization | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --remove-non-js-ops removes operations incompatible | |
| ;; CHECK-NEXT: with js | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --remove-relaxed-simd replaces relaxed SIMD | |
| ;; CHECK-NEXT: instructions with unreachable | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --remove-unused-brs removes breaks from locations | |
| ;; CHECK-NEXT: that are not needed | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --remove-unused-module-elements removes unused module elements | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --remove-unused-names removes names from locations | |
| ;; CHECK-NEXT: that are never branched to | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --remove-unused-nonfunction-module-elements removes unused module elements | |
| ;; CHECK-NEXT: that are not functions | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --remove-unused-types remove unused private GC types | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --reorder-functions sorts functions by access | |
| ;; CHECK-NEXT: frequency | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --reorder-functions-by-name sorts functions by name (useful | |
| ;; CHECK-NEXT: for debugging) | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --reorder-globals sorts globals by access | |
| ;; CHECK-NEXT: frequency | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --reorder-locals sorts locals by access frequency | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --reorder-types sorts private types by access | |
| ;; CHECK-NEXT: frequency | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --rereloop re-optimize control flow using | |
| ;; CHECK-NEXT: the relooper algorithm | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --roundtrip write the module to binary, then | |
| ;; CHECK-NEXT: read it | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --rse remove redundant local.sets | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --safe-heap instrument loads and stores to | |
| ;; CHECK-NEXT: check for invalid behavior | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --separate-data-segments write data segments to a file | |
| ;; CHECK-NEXT: and strip them from the module | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --set-globals sets specified globals to | |
| ;; CHECK-NEXT: specified values | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --signature-pruning remove params from function | |
| ;; CHECK-NEXT: signature types where possible | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --signature-refining apply more specific subtypes to | |
| ;; CHECK-NEXT: signature types where possible | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --signext-lowering lower sign-ext operations to | |
| ;; CHECK-NEXT: wasm mvp and disable the sign | |
| ;; CHECK-NEXT: extension feature | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --simplify-globals miscellaneous globals-related | |
| ;; CHECK-NEXT: optimizations | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --simplify-globals-optimizing miscellaneous globals-related | |
| ;; CHECK-NEXT: optimizations, and optimizes | |
| ;; CHECK-NEXT: where we replaced global.gets | |
| ;; CHECK-NEXT: with constants | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --simplify-locals miscellaneous locals-related | |
| ;; CHECK-NEXT: optimizations | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --simplify-locals-nonesting miscellaneous locals-related | |
| ;; CHECK-NEXT: optimizations (no nesting at | |
| ;; CHECK-NEXT: all; preserves flatness) | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --simplify-locals-nostructure miscellaneous locals-related | |
| ;; CHECK-NEXT: optimizations (no structure) | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --simplify-locals-notee miscellaneous locals-related | |
| ;; CHECK-NEXT: optimizations (no tees) | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --simplify-locals-notee-nostructure miscellaneous locals-related | |
| ;; CHECK-NEXT: optimizations (no tees or | |
| ;; CHECK-NEXT: structure) | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --souperify emit Souper IR in text form | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --souperify-single-use emit Souper IR in text form | |
| ;; CHECK-NEXT: (single-use nodes only) | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --spill-pointers spill pointers to the C stack | |
| ;; CHECK-NEXT: (useful for Boehm-style GC) | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --ssa ssa-ify variables so that they | |
| ;; CHECK-NEXT: have a single assignment | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --ssa-nomerge ssa-ify variables so that they | |
| ;; CHECK-NEXT: have a single assignment, | |
| ;; CHECK-NEXT: ignoring merges | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --stack-check enforce limits on llvm's | |
| ;; CHECK-NEXT: __stack_pointer global | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --string-gathering gathers wasm strings to globals | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --string-lifting lift string imports to wasm | |
| ;; CHECK-NEXT: strings | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --string-lowering lowers wasm strings and | |
| ;; CHECK-NEXT: operations to imports | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --string-lowering-magic-imports same as string-lowering, but | |
| ;; CHECK-NEXT: encodes well-formed strings as | |
| ;; CHECK-NEXT: magic imports | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --string-lowering-magic-imports-assert same as | |
| ;; CHECK-NEXT: string-lowering-magic-imports, | |
| ;; CHECK-NEXT: but raise a fatal error if there | |
| ;; CHECK-NEXT: are invalid strings | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --strip deprecated; same as strip-debug | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --strip-debug strip debug info (including the | |
| ;; CHECK-NEXT: names section) | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --strip-dwarf strip dwarf debug info | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --strip-eh strip EH instructions | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --strip-producers strip the wasm producers section | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --strip-target-features strip the wasm target features | |
| ;; CHECK-NEXT: section | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --strip-toolchain-annotations strip all toolchain-specific | |
| ;; CHECK-NEXT: code annotations | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --stub-unsupported-js stub out unsupported JS | |
| ;; CHECK-NEXT: operations | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --symbolmap (alias for print-function-map) | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --table64-lowering alias for memory64-lowering | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --tail-call convert calls in tail position | |
| ;; CHECK-NEXT: to return calls | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --trace-calls instrument the build with code | |
| ;; CHECK-NEXT: to intercept specific function | |
| ;; CHECK-NEXT: calls | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --translate-to-exnref translate old Phase 3 EH | |
| ;; CHECK-NEXT: instructions to new ones with | |
| ;; CHECK-NEXT: exnref | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --translate-to-new-eh deprecated; same as | |
| ;; CHECK-NEXT: translate-to-exnref | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --tuple-optimization optimize trivial tuples away | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --type-finalizing mark all leaf types as final | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --type-merging merge types to their supertypes | |
| ;; CHECK-NEXT: where possible | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --type-refining apply more specific subtypes to | |
| ;; CHECK-NEXT: type fields where possible | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --type-refining-gufa apply more specific subtypes to | |
| ;; CHECK-NEXT: type fields where possible | |
| ;; CHECK-NEXT: (using GUFA) | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --type-ssa create new types to help other | |
| ;; CHECK-NEXT: optimizations | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --type-unfinalizing mark all types as non-final | |
| ;; CHECK-NEXT: (open) | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --unsubtyping removes unnecessary subtyping | |
| ;; CHECK-NEXT: relationships | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --untee removes local.tees, replacing | |
| ;; CHECK-NEXT: them with sets and gets | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --vacuum removes obviously unneeded code | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: Optimization options: | |
| ;; CHECK-NEXT: --------------------- | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: -O execute default optimization | |
| ;; CHECK-NEXT: passes (equivalent to -Os) | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: -O0 execute no optimization passes | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: -O1 execute -O1 optimization passes | |
| ;; CHECK-NEXT: (quick&useful opts, useful for | |
| ;; CHECK-NEXT: iteration builds) | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: -O2 execute -O2 optimization passes | |
| ;; CHECK-NEXT: (most opts, generally gets most | |
| ;; CHECK-NEXT: perf) | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: -O3 execute -O3 optimization passes | |
| ;; CHECK-NEXT: (spends potentially a lot of | |
| ;; CHECK-NEXT: time optimizing) | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: -O4 execute -O4 optimization passes | |
| ;; CHECK-NEXT: (also flatten the IR, which can | |
| ;; CHECK-NEXT: take a lot more time and memory, | |
| ;; CHECK-NEXT: but is useful on more nested / | |
| ;; CHECK-NEXT: complex / less-optimized input) | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: -Os execute default optimization | |
| ;; CHECK-NEXT: passes, focusing on code size | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: -Oz execute default optimization | |
| ;; CHECK-NEXT: passes, super-focusing on code | |
| ;; CHECK-NEXT: size | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --optimize-level,-ol How much to focus on optimizing | |
| ;; CHECK-NEXT: code | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --shrink-level,-s How much to focus on shrinking | |
| ;; CHECK-NEXT: code size | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --debuginfo,-g Emit names section in wasm | |
| ;; CHECK-NEXT: binary (or full debuginfo in | |
| ;; CHECK-NEXT: wast) | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --always-inline-max-function-size,-aimfs Max size of functions that are | |
| ;; CHECK-NEXT: always inlined (default 2, which | |
| ;; CHECK-NEXT: is safe for use with -Os builds) | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --flexible-inline-max-function-size,-fimfs Max size of functions that are | |
| ;; CHECK-NEXT: inlined when lightweight (no | |
| ;; CHECK-NEXT: loops or function calls) when | |
| ;; CHECK-NEXT: optimizing aggressively for | |
| ;; CHECK-NEXT: speed (-O3). Default: 20 | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --one-caller-inline-max-function-size,-ocimfs Max size of functions that are | |
| ;; CHECK-NEXT: inlined when there is only one | |
| ;; CHECK-NEXT: caller (default -1, which means | |
| ;; CHECK-NEXT: all such functions are inlined) | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --inline-max-combined-binary-size,-imcbs Max size of combined functions | |
| ;; CHECK-NEXT: after inlining. Default: 409600 | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --inline-functions-with-loops,-ifwl Allow inlining functions with | |
| ;; CHECK-NEXT: loops | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --partial-inlining-ifs,-pii Number of ifs allowed in partial | |
| ;; CHECK-NEXT: inlining (zero means partial | |
| ;; CHECK-NEXT: inlining is disabled) (default: | |
| ;; CHECK-NEXT: 0) | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --ignore-implicit-traps,-iit Optimize under the helpful | |
| ;; CHECK-NEXT: assumption that no surprising | |
| ;; CHECK-NEXT: traps occur (from load, div/mod, | |
| ;; CHECK-NEXT: etc.) | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --traps-never-happen,-tnh Optimize under the helpful | |
| ;; CHECK-NEXT: assumption that no trap is | |
| ;; CHECK-NEXT: reached at runtime (from load, | |
| ;; CHECK-NEXT: div/mod, etc.) | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --low-memory-unused,-lmu Optimize under the helpful | |
| ;; CHECK-NEXT: assumption that the low 1K of | |
| ;; CHECK-NEXT: memory is not used by the | |
| ;; CHECK-NEXT: application | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --fast-math,-ffm Optimize floats without handling | |
| ;; CHECK-NEXT: corner cases of NaNs, rounding, | |
| ;; CHECK-NEXT: and negative zero | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --zero-filled-memory,-uim Assume that an imported memory | |
| ;; CHECK-NEXT: will be zero-initialized | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --skip-pass,-sp Skip a pass (do not run it) | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: Tool options: | |
| ;; CHECK-NEXT: ------------- | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --mvp-features,-mvp Disable all non-MVP features | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --all-features,-all Enable all features | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --detect-features (deprecated - this flag does | |
| ;; CHECK-NEXT: nothing) | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --quiet,-q Emit less verbose output and | |
| ;; CHECK-NEXT: hide trivial warnings. | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --experimental-poppy Parse wast files as Poppy IR for | |
| ;; CHECK-NEXT: testing purposes. | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --emit-module-names Emit module names, even if not | |
| ;; CHECK-NEXT: emitting the rest of the names | |
| ;; CHECK-NEXT: section. | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --enable-sign-ext Enable sign extension operations | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --disable-sign-ext Disable sign extension | |
| ;; CHECK-NEXT: operations | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --enable-threads Enable atomic operations | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --disable-threads Disable atomic operations | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --enable-mutable-globals Enable mutable globals | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --disable-mutable-globals Disable mutable globals | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --enable-nontrapping-float-to-int Enable nontrapping float-to-int | |
| ;; CHECK-NEXT: operations | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --disable-nontrapping-float-to-int Disable nontrapping float-to-int | |
| ;; CHECK-NEXT: operations | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --enable-simd Enable SIMD operations and types | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --disable-simd Disable SIMD operations and | |
| ;; CHECK-NEXT: types | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --enable-bulk-memory Enable bulk memory operations | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --disable-bulk-memory Disable bulk memory operations | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --enable-bulk-memory-opt Enable memory.copy and | |
| ;; CHECK-NEXT: memory.fill | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --disable-bulk-memory-opt Disable memory.copy and | |
| ;; CHECK-NEXT: memory.fill | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --enable-call-indirect-overlong Enable LEB encoding of | |
| ;; CHECK-NEXT: call-indirect (Ignored for | |
| ;; CHECK-NEXT: compatibility as it has no | |
| ;; CHECK-NEXT: effect on Binaryen) | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --disable-call-indirect-overlong Disable LEB encoding of | |
| ;; CHECK-NEXT: call-indirect (Ignored for | |
| ;; CHECK-NEXT: compatibility as it has no | |
| ;; CHECK-NEXT: effect on Binaryen) | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --enable-exception-handling Enable exception handling | |
| ;; CHECK-NEXT: operations | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --disable-exception-handling Disable exception handling | |
| ;; CHECK-NEXT: operations | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --enable-tail-call Enable tail call operations | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --disable-tail-call Disable tail call operations | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --enable-reference-types Enable reference types | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --disable-reference-types Disable reference types | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --enable-multivalue Enable multivalue functions | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --disable-multivalue Disable multivalue functions | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --enable-gc Enable garbage collection | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --disable-gc Disable garbage collection | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --enable-memory64 Enable memory64 | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --disable-memory64 Disable memory64 | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --enable-relaxed-simd Enable relaxed SIMD | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --disable-relaxed-simd Disable relaxed SIMD | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --enable-extended-const Enable extended const | |
| ;; CHECK-NEXT: expressions | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --disable-extended-const Disable extended const | |
| ;; CHECK-NEXT: expressions | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --enable-strings Enable strings | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --disable-strings Disable strings | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --enable-multimemory Enable multimemory | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --disable-multimemory Disable multimemory | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --enable-stack-switching Enable stack switching | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --disable-stack-switching Disable stack switching | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --enable-shared-everything Enable shared-everything threads | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --disable-shared-everything Disable shared-everything | |
| ;; CHECK-NEXT: threads | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --enable-fp16 Enable float 16 operations | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --disable-fp16 Disable float 16 operations | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --enable-custom-descriptors Enable custom descriptors (RTTs) | |
| ;; CHECK-NEXT: and exact references | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --disable-custom-descriptors Disable custom descriptors | |
| ;; CHECK-NEXT: (RTTs) and exact references | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --enable-multibyte Enable multibyte array loads and | |
| ;; CHECK-NEXT: stores | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --disable-multibyte Disable multibyte array loads | |
| ;; CHECK-NEXT: and stores | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --enable-acquire-release-atomics Enable acquire/release atomic | |
| ;; CHECK-NEXT: memory operations | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --disable-acquire-release-atomics Disable acquire/release atomic | |
| ;; CHECK-NEXT: memory operations | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --enable-custom-page-sizes Enable custom page sizes | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --disable-custom-page-sizes Disable custom page sizes | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --enable-wide-arithmetic Enable wide arithmetic | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --disable-wide-arithmetic Disable wide arithmetic | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --enable-compact-imports Enable compact import section | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --disable-compact-imports Disable compact import section | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --enable-relaxed-atomics Enable relaxed atomic memory | |
| ;; CHECK-NEXT: operations | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --disable-relaxed-atomics Disable relaxed atomic memory | |
| ;; CHECK-NEXT: operations | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --enable-typed-function-references Deprecated compatibility flag | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --disable-typed-function-references Deprecated compatibility flag | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --no-validation,-n Disables validation, assumes | |
| ;; CHECK-NEXT: inputs are correct | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --pass-arg,-pa An argument passed along to | |
| ;; CHECK-NEXT: optimization passes being run. | |
| ;; CHECK-NEXT: Must be in the form KEY@VALUE. | |
| ;; CHECK-NEXT: If KEY is the name of a pass | |
| ;; CHECK-NEXT: then it applies to the closest | |
| ;; CHECK-NEXT: instance of that pass before us. | |
| ;; CHECK-NEXT: If KEY is not the name of a pass | |
| ;; CHECK-NEXT: then it is a global option that | |
| ;; CHECK-NEXT: applies to all pass instances | |
| ;; CHECK-NEXT: that read it. | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --closed-world,-cw Assume code outside of the | |
| ;; CHECK-NEXT: module does not inspect or | |
| ;; CHECK-NEXT: interact with GC and function | |
| ;; CHECK-NEXT: references, even if they are | |
| ;; CHECK-NEXT: passed out. The outside may hold | |
| ;; CHECK-NEXT: on to them and pass them back | |
| ;; CHECK-NEXT: in, but not inspect their | |
| ;; CHECK-NEXT: contents or call them. | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --preserve-type-order Preserve the order of types from | |
| ;; CHECK-NEXT: the input (useful for debugging | |
| ;; CHECK-NEXT: and testing) | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --generate-stack-ir generate StackIR during writing | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --optimize-stack-ir optimize StackIR during writing | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --print-stack-ir print StackIR during writing | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --no-stack-ir do not use StackIR (even when it | |
| ;; CHECK-NEXT: is the default) | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: General options: | |
| ;; CHECK-NEXT: ---------------- | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --version Output version information and | |
| ;; CHECK-NEXT: exit | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --help,-h Show this help message and exit | |
| ;; CHECK-EMPTY: | |
| ;; CHECK-NEXT: --debug,-d Print debug information to | |
| ;; CHECK-NEXT: stderr | |
| ;; CHECK-EMPTY: |