;; RUN: wasm2js --help | filecheck %s ;; CHECK: ================================================================================ ;; CHECK-NEXT: wasm2js INFILE ;; CHECK-NEXT: ;; CHECK-NEXT: Transform .wasm/.wat files to asm.js ;; CHECK-NEXT: ================================================================================ ;; CHECK-NEXT: ;; CHECK-NEXT: ;; CHECK-NEXT: wasm2js options: ;; CHECK-NEXT: ---------------- ;; CHECK-NEXT: ;; CHECK-NEXT: --output,-o Output file (stdout if not ;; CHECK-NEXT: specified) ;; CHECK-NEXT: ;; CHECK-NEXT: --allow-asserts Allow compilation of .wast ;; CHECK-NEXT: testing asserts ;; CHECK-NEXT: ;; CHECK-NEXT: --pedantic Emulate WebAssembly trapping ;; CHECK-NEXT: behavior ;; CHECK-NEXT: ;; CHECK-NEXT: --emscripten Emulate the glue in ;; CHECK-NEXT: emscripten-compatible form (and ;; CHECK-NEXT: not ES6 module form) ;; CHECK-NEXT: ;; CHECK-NEXT: --deterministic Replace WebAssembly trapping ;; CHECK-NEXT: behavior deterministically (the ;; CHECK-NEXT: default is to not care about ;; CHECK-NEXT: what would trap in wasm, like a ;; CHECK-NEXT: load out of bounds or integer ;; CHECK-NEXT: divide by zero; with this flag, ;; CHECK-NEXT: we try to be deterministic at ;; CHECK-NEXT: least in what happens, which ;; CHECK-NEXT: might or might not be to trap ;; CHECK-NEXT: like wasm, but at least should ;; CHECK-NEXT: not vary) ;; CHECK-NEXT: ;; CHECK-NEXT: --symbols-file Emit a symbols file that maps ;; CHECK-NEXT: function indexes to their ;; CHECK-NEXT: original names ;; CHECK-NEXT: ;; CHECK-NEXT: ;; CHECK-NEXT: Optimization passes: ;; CHECK-NEXT: -------------------- ;; CHECK-NEXT: ;; CHECK-NEXT: --abstract-type-refining refine and merge abstract ;; CHECK-NEXT: (never-created) types ;; CHECK-NEXT: ;; CHECK-NEXT: --alignment-lowering lower unaligned loads and stores ;; CHECK-NEXT: to smaller aligned ones ;; CHECK-NEXT: ;; CHECK-NEXT: --asyncify async/await style transform, ;; CHECK-NEXT: allowing pausing and resuming ;; CHECK-NEXT: ;; CHECK-NEXT: --avoid-reinterprets Tries to avoid reinterpret ;; CHECK-NEXT: operations via more loads ;; CHECK-NEXT: ;; CHECK-NEXT: --cfp propagate constant struct field ;; CHECK-NEXT: values ;; CHECK-NEXT: ;; CHECK-NEXT: --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: --legalize-js-interface-minimally legalizes i64 types on the ;; CHECK-NEXT: import/export boundary in a ;; CHECK-NEXT: minimal manner, only on things ;; CHECK-NEXT: only JS will call ;; CHECK-NEXT: ;; CHECK-NEXT: --licm loop invariant code motion ;; CHECK-NEXT: ;; CHECK-NEXT: --limit-segments attempt to merge segments to fit ;; CHECK-NEXT: within web limits ;; CHECK-NEXT: ;; CHECK-NEXT: --local-cse common subexpression elimination ;; CHECK-NEXT: inside basic blocks ;; CHECK-NEXT: ;; CHECK-NEXT: --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: