/usr/bin/wasm-ctor-eval

================================================================================
wasm-ctor-eval INFILE

Execute code at compile time
================================================================================


wasm-ctor-eval options:
-----------------------

  --output,-o                          Output file

  --emit-text,-S                       Emit text instead of binary for the
                                       output file

  --debuginfo,-g                       Emit names section and debug info

  --ctors,-c                           Comma-separated list of global
                                       constructor functions to evaluate

  --kept-exports,-ke                   Comma-separated list of ctors whose
                                       exports we keep around even if we eval
                                       those ctors

  --ignore-external-input,-ipi         Assumes no env vars are to be read, stdin
                                       is empty, etc.

  --quiet,-q                           Do not emit verbose logging about the
                                       eval process


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