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