/usr/bin/wasm-emscripten-finalize

================================================================================
wasm-emscripten-finalize INFILE

Performs Emscripten-specific transforms on .wasm files
================================================================================


wasm-emscripten-finalize options:
---------------------------------

  --output,-o                          Output file

  --debuginfo,-g                       Emit names section in wasm binary (or
                                       full debuginfo in wast)

  --dwarf                              Update DWARF debug info

  --emit-text,-S                       Emit text instead of binary for the
                                       output file. In this mode if no output
                                       file is specified, we write to stdout.

  --side-module                        Input is an emscripten side module

  --input-source-map,-ism              Consume source map from the specified
                                       file

  --bigint,-bi                         Assume JS will use wasm/JS BigInt
                                       integration, so wasm i64s will turn into
                                       JS BigInts, and there is no need for any
                                       legalization at all (not even minimal
                                       legalization of dynCalls)

  --output-source-map,-osm             Emit source map to the specified file

  --output-source-map-url,-osu         Emit specified string as source map URL

  --check-stack-overflow               Check for stack overflows every time the
                                       stack is extended

  --standalone-wasm                    Emit a wasm file that does not depend on
                                       JS, as much as possible, using wasi and
                                       other standard conventions etc. where
                                       possible

  --minimize-wasm-changes              Modify the wasm as little as possible.
                                       This is useful during development as we
                                       reduce the number of changes to the wasm,
                                       as it lets emscripten control how much
                                       modifications to do.

  --no-dyncalls

  --dyncalls-i64


Tool options:
-------------

  --mvp-features,-mvp                  Disable all non-MVP features

  --all-features,-all                  Enable all features

  --detect-features                    (deprecated - this flag does nothing)

  --quiet,-q                           Emit less verbose output and hide trivial
                                       warnings.

  --experimental-poppy                 Parse wast files as Poppy IR for testing
                                       purposes.

  --emit-module-names                  Emit module names, even if not emitting
                                       the rest of the names section.

  --enable-sign-ext                    Enable sign extension operations

  --disable-sign-ext                   Disable sign extension operations

  --enable-threads                     Enable atomic operations

  --disable-threads                    Disable atomic operations

  --enable-mutable-globals             Enable mutable globals

  --disable-mutable-globals            Disable mutable globals

  --enable-nontrapping-float-to-int    Enable nontrapping float-to-int
                                       operations

  --disable-nontrapping-float-to-int   Disable nontrapping float-to-int
                                       operations

  --enable-simd                        Enable SIMD operations and types

  --disable-simd                       Disable SIMD operations and types

  --enable-bulk-memory                 Enable bulk memory operations

  --disable-bulk-memory                Disable bulk memory operations

  --enable-bulk-memory-opt             Enable memory.copy and memory.fill

  --disable-bulk-memory-opt            Disable memory.copy and memory.fill

  --enable-call-indirect-overlong      Enable LEB encoding of call-indirect
                                       (Ignored for compatibility as it has no
                                       effect on Binaryen)

  --disable-call-indirect-overlong     Disable LEB encoding of call-indirect
                                       (Ignored for compatibility as it has no
                                       effect on Binaryen)

  --enable-exception-handling          Enable exception handling operations

  --disable-exception-handling         Disable exception handling operations

  --enable-tail-call                   Enable tail call operations

  --disable-tail-call                  Disable tail call operations

  --enable-reference-types             Enable reference types

  --disable-reference-types            Disable reference types

  --enable-multivalue                  Enable multivalue functions

  --disable-multivalue                 Disable multivalue functions

  --enable-gc                          Enable garbage collection

  --disable-gc                         Disable garbage collection

  --enable-memory64                    Enable memory64

  --disable-memory64                   Disable memory64

  --enable-relaxed-simd                Enable relaxed SIMD

  --disable-relaxed-simd               Disable relaxed SIMD

  --enable-extended-const              Enable extended const expressions

  --disable-extended-const             Disable extended const expressions

  --enable-strings                     Enable strings

  --disable-strings                    Disable strings

  --enable-multimemory                 Enable multimemory

  --disable-multimemory                Disable multimemory

  --enable-stack-switching             Enable stack switching

  --disable-stack-switching            Disable stack switching

  --enable-shared-everything           Enable shared-everything threads

  --disable-shared-everything          Disable shared-everything threads

  --enable-fp16                        Enable float 16 operations

  --disable-fp16                       Disable float 16 operations

  --enable-custom-descriptors          Enable custom descriptors (RTTs) and
                                       exact references

  --disable-custom-descriptors         Disable custom descriptors (RTTs) and
                                       exact references

  --enable-multibyte                   Enable multibyte array loads and stores

  --disable-multibyte                  Disable multibyte array loads and stores

  --enable-acquire-release-atomics     Enable acquire/release atomic memory
                                       operations

  --disable-acquire-release-atomics    Disable acquire/release atomic memory
                                       operations

  --enable-custom-page-sizes           Enable custom page sizes

  --disable-custom-page-sizes          Disable custom page sizes

  --enable-wide-arithmetic             Enable wide arithmetic

  --disable-wide-arithmetic            Disable wide arithmetic

  --enable-compact-imports             Enable compact import section

  --disable-compact-imports            Disable compact import section

  --enable-relaxed-atomics             Enable relaxed atomic memory operations

  --disable-relaxed-atomics            Disable relaxed atomic memory operations

  --enable-typed-function-references   Deprecated compatibility flag

  --disable-typed-function-references  Deprecated compatibility flag

  --no-validation,-n                   Disables validation, assumes inputs are
                                       correct

  --pass-arg,-pa                       An argument passed along to optimization
                                       passes being run. Must be in the form
                                       KEY@VALUE.  If KEY is the name of a pass
                                       then it applies to the closest instance
                                       of that pass before us. If KEY is not the
                                       name of a pass then it is a global option
                                       that applies to all pass instances that
                                       read it.

  --closed-world,-cw                   Assume code outside of the module does
                                       not inspect or interact with GC and
                                       function references, even if they are
                                       passed out. The outside may hold on to
                                       them and pass them back in, but not
                                       inspect their contents or call them.

  --preserve-type-order                Preserve the order of types from the
                                       input (useful for debugging and testing)

  --generate-stack-ir                  generate StackIR during writing

  --optimize-stack-ir                  optimize StackIR during writing

  --print-stack-ir                     print StackIR during writing


General options:
----------------

  --version                            Output version information and exit

  --help,-h                            Show this help message and exit

  --debug,-d                           Print debug information to stderr