diff --git a/README.md b/README.md --- a/README.md +++ b/README.md @@ -8,31 +8,44 @@ ## Versioning -Binaryen evolves fast and can introduce C API changes in every release. Before -building the Haskell bindings, please check the Binaryen version and make sure +Starting from `0.0.5.0`, we bundle the C++ sources of `binaryen` with this +package, so the package can be built and used as long as the C++ toolchain is +present in the build environment. The `system-binaryen` Cabal flag defaults to +`False`, but it can be manually enabled to link against the system-wide +`binaryen` library and avoid building the bundled C++ library. + +| Haskell bindings version | Bundled Binaryen version | +| ------------------------ | ------------------------ | +| 0.0.5.\* | version_98 | + +Older versions of this package links against the system-wide `binaryen` library, +so before building the package, please check the Binaryen version and make sure it's no less than the minimum version listed below. | Haskell bindings version | Minimum Binaryen version | -|--------------------------|--------------------------| -| 0.0.1.* | version_91 | -| 0.0.2.* | version_94 | -| 0.0.3.* | version_96 | -| 0.0.4.* | version_97 | - +| ------------------------ | ------------------------ | +| 0.0.1.\* | version_91 | +| 0.0.2.\* | version_94 | +| 0.0.3.\* | version_96 | +| 0.0.4.\* | version_97 | ## How to build -This package relies on the system-provided Binaryen library. As long as that's -available, a simple `stack build` or `cabal build` command should work. +A simple `stack build` or `cabal build` command should work. -`Nix`-based build is also supported. Install [Stack][stack] and [Nix][nix]. -Then, +For Windows `cabal` users: run the build in a msys2 mingw64 shell. +[`nix`][nix]-based build is also supported: + ```shell -$ stack --nix build +$ nix-shell --pure --run "cabal v2-run binaryen:test" +$ nix-shell --pure --run "cabal v2-run binaryen:test --flags=system-binaryen --extra-include-dirs=\$binaryenIncludeDir --extra-lib-dirs=\$binaryenLibDir" ``` +Use the [`asterius`][cachix-asterius] Cachix bucket for reusing binary cache +built on CI. + [binaryen]: https://github.com/WebAssembly/binaryen [binaryen-api]: https://github.com/WebAssembly/binaryen/blob/master/src/binaryen-c.h +[cachix-asterius]: https://app.cachix.org/cache/asterius [nix]: https://nixos.org/nix -[stack]: https://docs.haskellstack.org/en/stable/README diff --git a/Setup.hs b/Setup.hs deleted file mode 100644 --- a/Setup.hs +++ /dev/null @@ -1,2 +0,0 @@ -import Distribution.Simple -main = defaultMain diff --git a/binaryen.cabal b/binaryen.cabal --- a/binaryen.cabal +++ b/binaryen.cabal @@ -1,59 +1,2168 @@ -cabal-version: 1.12 - --- This file has been generated from package.yaml by hpack version 0.33.0. --- --- see: https://github.com/sol/hpack --- --- hash: a97a536c6a54def78b714cf926b75e3dc2ede559d014ec6295143c608c11c1c9 - -name: binaryen -version: 0.0.4.0 -synopsis: Haskell bindings to binaryen -description: Haskell bindings to [binaryen](https://github.com/WebAssembly/binaryen). Provides complete bindings to the C API, which can be useful for building WebAssembly toolchains in Haskell. -category: Compiler -homepage: https://github.com/tweag/haskell-binaryen#readme -bug-reports: https://github.com/tweag/haskell-binaryen/issues -maintainer: Cheng Shao -copyright: (c) 2018 Tweag I/O -license: BSD3 -license-file: LICENSE -build-type: Simple -extra-source-files: - CHANGELOG.md - LICENSE - README.md - -source-repository head - type: git - location: https://github.com/tweag/haskell-binaryen - -library - exposed-modules: - Binaryen - Binaryen.Event - Binaryen.Export - Binaryen.Expression - Binaryen.ExpressionId - Binaryen.ExternalKind - Binaryen.Features - Binaryen.Function - Binaryen.Global - Binaryen.Index - Binaryen.Module - Binaryen.Op - Binaryen.Relooper - Binaryen.SideEffects - Binaryen.Type - other-modules: - Paths_binaryen - hs-source-dirs: - src - ghc-options: -Wall - c-sources: - cbits/wrappers.c - extra-libraries: - binaryen - stdc++ - build-depends: - base <5 +cabal-version: 2.2 + +-- This file has been generated from package.yaml by hpack version 0.33.0. +-- +-- see: https://github.com/sol/hpack +-- +-- hash: dd229f4cad11bdebeaef89df68685de75858bc5d1ec3d969f606f0519e5e34b8 + +name: binaryen +version: 0.0.5.0 +synopsis: Haskell bindings to binaryen +description: Haskell bindings to [binaryen](https://github.com/WebAssembly/binaryen). Provides complete bindings to the C API, which can be useful for building WebAssembly toolchains in Haskell. +category: Compiler +homepage: https://github.com/tweag/haskell-binaryen#readme +bug-reports: https://github.com/tweag/haskell-binaryen/issues +maintainer: Cheng Shao +copyright: (c) 2018 Tweag I/O +license: BSD-3-Clause +license-file: LICENSE +build-type: Simple +extra-source-files: + binaryen/auto_update_tests.py + binaryen/CHANGELOG.md + binaryen/check.py + binaryen/CMakeLists.txt + binaryen/config.h.in + binaryen/Contributing.md + binaryen/LICENSE + binaryen/media/example.png + binaryen/README.md + binaryen/scripts/__init__.py + binaryen/scripts/clang-format-diff.sh + binaryen/scripts/clang-tidy-diff.sh + binaryen/scripts/clean_c_api_trace.py + binaryen/scripts/embedwat.py + binaryen/scripts/emcc-tests.sh + binaryen/scripts/fuzz_opt.py + binaryen/scripts/fuzz_passes.py + binaryen/scripts/fuzz_passes_wast.py + binaryen/scripts/fuzz_relooper.py + binaryen/scripts/fuzz_shell.js + binaryen/scripts/gen-s-parser.py + binaryen/scripts/process_optimize_instructions.py + binaryen/scripts/storage.py + binaryen/scripts/strip_local_names.py + binaryen/scripts/test/__init__.py + binaryen/scripts/test/binaryenjs.py + binaryen/scripts/test/env.js + binaryen/scripts/test/generate_lld_tests.py + binaryen/scripts/test/lld.py + binaryen/scripts/test/mod.ule.js + binaryen/scripts/test/node-esm-loader.mjs + binaryen/scripts/test/shared.py + binaryen/scripts/test/spectest.js + binaryen/scripts/test/support.py + binaryen/scripts/test/wasm2js.py + binaryen/scripts/test/wasm_opt.py + binaryen/scripts/validation_shell.js + binaryen/scripts/wasm2js.js + binaryen/src/abi/abi.h + binaryen/src/abi/js.h + binaryen/src/abi/stack.h + binaryen/src/abi/wasm-object.h + binaryen/src/asm_v_wasm.h + binaryen/src/asmjs/asm_v_wasm.cpp + binaryen/src/asmjs/asmangle.cpp + binaryen/src/asmjs/asmangle.h + binaryen/src/asmjs/CMakeLists.txt + binaryen/src/asmjs/shared-constants.cpp + binaryen/src/asmjs/shared-constants.h + binaryen/src/binaryen-c.cpp + binaryen/src/binaryen-c.h + binaryen/src/cfg/cfg-traversal.h + binaryen/src/cfg/CMakeLists.txt + binaryen/src/cfg/liveness-traversal.h + binaryen/src/cfg/Relooper.cpp + binaryen/src/cfg/Relooper.h + binaryen/src/compiler-support.h + binaryen/src/config.h + binaryen/src/dataflow/graph.h + binaryen/src/dataflow/node.h + binaryen/src/dataflow/users.h + binaryen/src/dataflow/utils.h + binaryen/src/emscripten-optimizer/CMakeLists.txt + binaryen/src/emscripten-optimizer/istring.h + binaryen/src/emscripten-optimizer/optimizer-shared.cpp + binaryen/src/emscripten-optimizer/optimizer.h + binaryen/src/emscripten-optimizer/parser.cpp + binaryen/src/emscripten-optimizer/parser.h + binaryen/src/emscripten-optimizer/simple_ast.cpp + binaryen/src/emscripten-optimizer/simple_ast.h + binaryen/src/emscripten-optimizer/snprintf.h + binaryen/src/gen-s-parser.inc + binaryen/src/ir/abstract.h + binaryen/src/ir/bits.h + binaryen/src/ir/block-utils.h + binaryen/src/ir/branch-utils.h + binaryen/src/ir/CMakeLists.txt + binaryen/src/ir/cost.h + binaryen/src/ir/debug.h + binaryen/src/ir/effects.h + binaryen/src/ir/equivalent_sets.h + binaryen/src/ir/ExpressionAnalyzer.cpp + binaryen/src/ir/ExpressionManipulator.cpp + binaryen/src/ir/features.h + binaryen/src/ir/find_all.h + binaryen/src/ir/flat.h + binaryen/src/ir/function-utils.h + binaryen/src/ir/global-utils.h + binaryen/src/ir/hashed.h + binaryen/src/ir/import-utils.h + binaryen/src/ir/iteration.h + binaryen/src/ir/label-utils.h + binaryen/src/ir/literal-utils.h + binaryen/src/ir/load-utils.h + binaryen/src/ir/local-graph.h + binaryen/src/ir/local-utils.h + binaryen/src/ir/LocalGraph.cpp + binaryen/src/ir/localize.h + binaryen/src/ir/manipulation.h + binaryen/src/ir/match.h + binaryen/src/ir/memory-utils.h + binaryen/src/ir/module-utils.h + binaryen/src/ir/names.h + binaryen/src/ir/parents.h + binaryen/src/ir/properties.h + binaryen/src/ir/ReFinalize.cpp + binaryen/src/ir/stack-utils.cpp + binaryen/src/ir/stack-utils.h + binaryen/src/ir/table-utils.h + binaryen/src/ir/trapping.h + binaryen/src/ir/type-updating.h + binaryen/src/ir/utils.h + binaryen/src/js/binaryen.js-extern-post.js + binaryen/src/js/binaryen.js-extern-pre.js + binaryen/src/js/binaryen.js-post.js + binaryen/src/literal.h + binaryen/src/mixed_arena.h + binaryen/src/parsing.h + binaryen/src/pass.h + binaryen/src/passes/AlignmentLowering.cpp + binaryen/src/passes/Asyncify.cpp + binaryen/src/passes/AvoidReinterprets.cpp + binaryen/src/passes/CMakeLists.txt + binaryen/src/passes/CoalesceLocals.cpp + binaryen/src/passes/CodeFolding.cpp + binaryen/src/passes/CodePushing.cpp + binaryen/src/passes/ConstHoisting.cpp + binaryen/src/passes/DataFlowOpts.cpp + binaryen/src/passes/DeadArgumentElimination.cpp + binaryen/src/passes/DeadCodeElimination.cpp + binaryen/src/passes/DeAlign.cpp + binaryen/src/passes/DeNaN.cpp + binaryen/src/passes/Directize.cpp + binaryen/src/passes/DuplicateFunctionElimination.cpp + binaryen/src/passes/DuplicateImportElimination.cpp + binaryen/src/passes/DWARF.cpp + binaryen/src/passes/EmscriptenPIC.cpp + binaryen/src/passes/ExtractFunction.cpp + binaryen/src/passes/Flatten.cpp + binaryen/src/passes/FuncCastEmulation.cpp + binaryen/src/passes/GenerateDynCalls.cpp + binaryen/src/passes/I64ToI32Lowering.cpp + binaryen/src/passes/Inlining.cpp + binaryen/src/passes/InstrumentLocals.cpp + binaryen/src/passes/InstrumentMemory.cpp + binaryen/src/passes/intrinsics-module.h + binaryen/src/passes/LegalizeJSInterface.cpp + binaryen/src/passes/LimitSegments.cpp + binaryen/src/passes/LocalCSE.cpp + binaryen/src/passes/LogExecution.cpp + binaryen/src/passes/LoopInvariantCodeMotion.cpp + binaryen/src/passes/MemoryPacking.cpp + binaryen/src/passes/MergeBlocks.cpp + binaryen/src/passes/MergeLocals.cpp + binaryen/src/passes/Metrics.cpp + binaryen/src/passes/MinifyImportsAndExports.cpp + binaryen/src/passes/NameList.cpp + binaryen/src/passes/NoExitRuntime.cpp + binaryen/src/passes/opt-utils.h + binaryen/src/passes/OptimizeAddedConstants.cpp + binaryen/src/passes/OptimizeInstructions.cpp + binaryen/src/passes/pass.cpp + binaryen/src/passes/passes.h + binaryen/src/passes/PickLoadSigns.cpp + binaryen/src/passes/PostAssemblyScript.cpp + binaryen/src/passes/PostEmscripten.cpp + binaryen/src/passes/Precompute.cpp + binaryen/src/passes/Print.cpp + binaryen/src/passes/PrintCallGraph.cpp + binaryen/src/passes/PrintFeatures.cpp + binaryen/src/passes/PrintFunctionMap.cpp + binaryen/src/passes/RedundantSetElimination.cpp + binaryen/src/passes/RemoveImports.cpp + binaryen/src/passes/RemoveMemory.cpp + binaryen/src/passes/RemoveNonJSOps.cpp + binaryen/src/passes/RemoveUnusedBrs.cpp + binaryen/src/passes/RemoveUnusedModuleElements.cpp + binaryen/src/passes/RemoveUnusedNames.cpp + binaryen/src/passes/ReorderFunctions.cpp + binaryen/src/passes/ReorderLocals.cpp + binaryen/src/passes/ReplaceStackPointer.cpp + binaryen/src/passes/ReReloop.cpp + binaryen/src/passes/RoundTrip.cpp + binaryen/src/passes/SafeHeap.cpp + binaryen/src/passes/SimplifyGlobals.cpp + binaryen/src/passes/SimplifyLocals.cpp + binaryen/src/passes/Souperify.cpp + binaryen/src/passes/SpillPointers.cpp + binaryen/src/passes/SSAify.cpp + binaryen/src/passes/StackCheck.cpp + binaryen/src/passes/StackIR.cpp + binaryen/src/passes/Strip.cpp + binaryen/src/passes/StripTargetFeatures.cpp + binaryen/src/passes/TrapMode.cpp + binaryen/src/passes/Untee.cpp + binaryen/src/passes/Vacuum.cpp + binaryen/src/passes/wasm-intrinsics.wat + binaryen/src/passes/WasmIntrinsics.cpp + binaryen/src/pretty_printing.h + binaryen/src/shared-constants.h + binaryen/src/shell-interface.h + binaryen/src/support/alloc.h + binaryen/src/support/archive.cpp + binaryen/src/support/archive.h + binaryen/src/support/base64.h + binaryen/src/support/bits.cpp + binaryen/src/support/bits.h + binaryen/src/support/CMakeLists.txt + binaryen/src/support/colors.cpp + binaryen/src/support/colors.h + binaryen/src/support/command-line.cpp + binaryen/src/support/command-line.h + binaryen/src/support/debug.cpp + binaryen/src/support/debug.h + binaryen/src/support/file.cpp + binaryen/src/support/file.h + binaryen/src/support/hash.h + binaryen/src/support/json.h + binaryen/src/support/learning.h + binaryen/src/support/name.h + binaryen/src/support/path.cpp + binaryen/src/support/path.h + binaryen/src/support/permutations.h + binaryen/src/support/safe_integer.cpp + binaryen/src/support/safe_integer.h + binaryen/src/support/small_vector.h + binaryen/src/support/sorted_vector.h + binaryen/src/support/string.h + binaryen/src/support/threads.cpp + binaryen/src/support/threads.h + binaryen/src/support/timing.h + binaryen/src/support/unique_deferring_queue.h + binaryen/src/support/utilities.cpp + binaryen/src/support/utilities.h + binaryen/src/templates/normal.js + binaryen/src/templates/wasm.js + binaryen/src/tools/execution-results.h + binaryen/src/tools/fuzzing.h + binaryen/src/tools/js-wrapper.h + binaryen/src/tools/optimization-options.h + binaryen/src/tools/spec-wrapper.h + binaryen/src/tools/tool-options.h + binaryen/src/tools/tool-utils.h + binaryen/src/tools/wasm-as.cpp + binaryen/src/tools/wasm-ctor-eval.cpp + binaryen/src/tools/wasm-dis.cpp + binaryen/src/tools/wasm-emscripten-finalize.cpp + binaryen/src/tools/wasm-metadce.cpp + binaryen/src/tools/wasm-opt.cpp + binaryen/src/tools/wasm-reduce.cpp + binaryen/src/tools/wasm-shell.cpp + binaryen/src/tools/wasm2c-wrapper.h + binaryen/src/tools/wasm2js.cpp + binaryen/src/wasm-binary.h + binaryen/src/wasm-builder.h + binaryen/src/wasm-debug.h + binaryen/src/wasm-emscripten.h + binaryen/src/wasm-features.h + binaryen/src/wasm-interpreter.h + binaryen/src/wasm-io.h + binaryen/src/wasm-module-building.h + binaryen/src/wasm-printing.h + binaryen/src/wasm-s-parser.h + binaryen/src/wasm-stack.h + binaryen/src/wasm-traversal.h + binaryen/src/wasm-type.h + binaryen/src/wasm-validator.h + binaryen/src/wasm.h + binaryen/src/wasm/CMakeLists.txt + binaryen/src/wasm/literal.cpp + binaryen/src/wasm/wasm-binary.cpp + binaryen/src/wasm/wasm-debug.cpp + binaryen/src/wasm/wasm-emscripten.cpp + binaryen/src/wasm/wasm-interpreter.cpp + binaryen/src/wasm/wasm-io.cpp + binaryen/src/wasm/wasm-s-parser.cpp + binaryen/src/wasm/wasm-stack.cpp + binaryen/src/wasm/wasm-type.cpp + binaryen/src/wasm/wasm-validator.cpp + binaryen/src/wasm/wasm.cpp + binaryen/src/wasm2js.h + binaryen/test/__init__.py + binaryen/test/atomics-unshared.wast + binaryen/test/atomics-unshared.wast.from-wast + binaryen/test/atomics-unshared.wast.fromBinary + binaryen/test/atomics-unshared.wast.fromBinary.noDebugInfo + binaryen/test/atomics.wast + binaryen/test/atomics.wast.from-wast + binaryen/test/atomics.wast.fromBinary + binaryen/test/atomics.wast.fromBinary.noDebugInfo + binaryen/test/atomics64.wast + binaryen/test/atomics64.wast.from-wast + binaryen/test/atomics64.wast.fromBinary + binaryen/test/atomics64.wast.fromBinary.noDebugInfo + binaryen/test/bad_params.asm.js + binaryen/test/bigswitch.cpp + binaryen/test/bigswitch.txt + binaryen/test/binaryen.js/atomics.js + binaryen/test/binaryen.js/atomics.js.txt + binaryen/test/binaryen.js/copy-expression.js + binaryen/test/binaryen.js/copy-expression.js.txt + binaryen/test/binaryen.js/custom-section.js + binaryen/test/binaryen.js/custom-section.js.txt + binaryen/test/binaryen.js/debug-info.js + binaryen/test/binaryen.js/debug-info.js.txt + binaryen/test/binaryen.js/debug-names.js + binaryen/test/binaryen.js/debug-names.js.txt + binaryen/test/binaryen.js/emit_asmjs.js + binaryen/test/binaryen.js/emit_asmjs.js.txt + binaryen/test/binaryen.js/event.js + binaryen/test/binaryen.js/event.js.txt + binaryen/test/binaryen.js/exception-handling.js + binaryen/test/binaryen.js/exception-handling.js.txt + binaryen/test/binaryen.js/expressionrunner.js + binaryen/test/binaryen.js/expressionrunner.js.txt + binaryen/test/binaryen.js/expressions.js + binaryen/test/binaryen.js/expressions.js.txt + binaryen/test/binaryen.js/fast-math.js + binaryen/test/binaryen.js/fast-math.js.txt + binaryen/test/binaryen.js/functions.js + binaryen/test/binaryen.js/functions.js.txt + binaryen/test/binaryen.js/global.js + binaryen/test/binaryen.js/global.js.txt + binaryen/test/binaryen.js/hello-world.js + binaryen/test/binaryen.js/hello-world.js.txt + binaryen/test/binaryen.js/inlining-options.js + binaryen/test/binaryen.js/inlining-options.js.txt + binaryen/test/binaryen.js/kitchen-sink.js + binaryen/test/binaryen.js/kitchen-sink.js.txt + binaryen/test/binaryen.js/low-memory-unused.js + binaryen/test/binaryen.js/low-memory-unused.js.txt + binaryen/test/binaryen.js/optimize-levels.js + binaryen/test/binaryen.js/optimize-levels.js.txt + binaryen/test/binaryen.js/pass-arguments.js + binaryen/test/binaryen.js/pass-arguments.js.txt + binaryen/test/binaryen.js/reloc.js + binaryen/test/binaryen.js/reloc.js.txt + binaryen/test/binaryen.js/sideffects.js + binaryen/test/binaryen.js/sideffects.js.txt + binaryen/test/binaryen.js/sieve.js + binaryen/test/binaryen.js/sieve.js.txt + binaryen/test/binaryen.js/simd.js + binaryen/test/binaryen.js/simd.js.txt + binaryen/test/binaryen.js/sourcemap.js + binaryen/test/binaryen.js/sourcemap.js.txt + binaryen/test/binaryen.js/stackir.js + binaryen/test/binaryen.js/stackir.js.txt + binaryen/test/binaryen.js/tail_calls.js + binaryen/test/binaryen.js/tail_calls.js.txt + binaryen/test/binaryen.js/validation_errors.js + binaryen/test/binaryen.js/validation_errors.js.txt + binaryen/test/br_to_exit.wasm + binaryen/test/br_to_exit.wasm.fromBinary + binaryen/test/break-to-return.wasm + binaryen/test/break-to-return.wasm.fromBinary + binaryen/test/break-within-catch.wasm + binaryen/test/break-within-catch.wasm.fromBinary + binaryen/test/calls.cpp + binaryen/test/calls.emcc + binaryen/test/calls.post.js + binaryen/test/calls.txt + binaryen/test/complexBinaryNames.wasm + binaryen/test/complexBinaryNames.wasm.fromBinary + binaryen/test/complexTextNames.wast + binaryen/test/complexTextNames.wast.from-wast + binaryen/test/complexTextNames.wast.fromBinary + binaryen/test/complexTextNames.wast.fromBinary.noDebugInfo + binaryen/test/consume-stacky.wasm + binaryen/test/consume-stacky.wasm.fromBinary + binaryen/test/control_flow.cpp + binaryen/test/control_flow.emcc + binaryen/test/control_flow.post.js + binaryen/test/control_flow.txt + binaryen/test/crash/expression-past-end-of-input.wasm + binaryen/test/crash/outside.wasm + binaryen/test/crash/use_var_outside_func.wasm + binaryen/test/ctor-eval/bad-indirect-call.wast + binaryen/test/ctor-eval/bad-indirect-call.wast.ctors + binaryen/test/ctor-eval/bad-indirect-call.wast.out + binaryen/test/ctor-eval/bad-indirect-call2.wast + binaryen/test/ctor-eval/bad-indirect-call2.wast.ctors + binaryen/test/ctor-eval/bad-indirect-call2.wast.out + binaryen/test/ctor-eval/bad-indirect-call3.wast + binaryen/test/ctor-eval/bad-indirect-call3.wast.ctors + binaryen/test/ctor-eval/bad-indirect-call3.wast.out + binaryen/test/ctor-eval/basics-flatten.wast + binaryen/test/ctor-eval/basics-flatten.wast.ctors + binaryen/test/ctor-eval/basics-flatten.wast.out + binaryen/test/ctor-eval/basics.wast + binaryen/test/ctor-eval/basics.wast.ctors + binaryen/test/ctor-eval/basics.wast.out + binaryen/test/ctor-eval/imported-min.wast + binaryen/test/ctor-eval/imported-min.wast.ctors + binaryen/test/ctor-eval/imported-min.wast.out + binaryen/test/ctor-eval/imported.wast + binaryen/test/ctor-eval/imported.wast.ctors + binaryen/test/ctor-eval/imported.wast.out + binaryen/test/ctor-eval/imported2.wast + binaryen/test/ctor-eval/imported2.wast.ctors + binaryen/test/ctor-eval/imported2.wast.out + binaryen/test/ctor-eval/imported3.wast + binaryen/test/ctor-eval/imported3.wast.ctors + binaryen/test/ctor-eval/imported3.wast.out + binaryen/test/ctor-eval/indirect-call3.wast + binaryen/test/ctor-eval/indirect-call3.wast.ctors + binaryen/test/ctor-eval/indirect-call3.wast.out + binaryen/test/ctor-eval/just_some.wast + binaryen/test/ctor-eval/just_some.wast.ctors + binaryen/test/ctor-eval/just_some.wast.out + binaryen/test/ctor-eval/no_partial.wast + binaryen/test/ctor-eval/no_partial.wast.ctors + binaryen/test/ctor-eval/no_partial.wast.out + binaryen/test/ctor-eval/stack-direction.wast + binaryen/test/ctor-eval/stack-direction.wast.ctors + binaryen/test/ctor-eval/stack-direction.wast.out + binaryen/test/ctor-eval/unsafe_call.wast + binaryen/test/ctor-eval/unsafe_call.wast.ctors + binaryen/test/ctor-eval/unsafe_call.wast.out + binaryen/test/ctor-eval/unsafe_store.wast + binaryen/test/ctor-eval/unsafe_store.wast.ctors + binaryen/test/ctor-eval/unsafe_store.wast.out + binaryen/test/ctor-eval/unsafe_store2.wast + binaryen/test/ctor-eval/unsafe_store2.wast.ctors + binaryen/test/ctor-eval/unsafe_store2.wast.out + binaryen/test/ctor-eval/unsafe_store3.wast + binaryen/test/ctor-eval/unsafe_store3.wast.ctors + binaryen/test/ctor-eval/unsafe_store3.wast.out + binaryen/test/debugInfo.asm.js + binaryen/test/duplicate_types.wast + binaryen/test/duplicate_types.wast.from-wast + binaryen/test/duplicate_types.wast.fromBinary + binaryen/test/duplicate_types.wast.fromBinary.noDebugInfo + binaryen/test/duplicated_names.wasm + binaryen/test/duplicated_names.wasm.fromBinary + binaryen/test/duplicated_names_collision.wasm + binaryen/test/duplicated_names_collision.wasm.fromBinary + binaryen/test/dylib.wasm + binaryen/test/dylib.wasm.fromBinary + binaryen/test/dynamicLibrary.asm.js + binaryen/test/elided-br.wasm + binaryen/test/elided-br.wasm.fromBinary + binaryen/test/emcc_hello_world.asm.js + binaryen/test/emcc_O2_hello_world.asm.js + binaryen/test/empty.asm.js + binaryen/test/empty_4GB.asm.js + binaryen/test/empty_imported_table.wast + binaryen/test/empty_imported_table.wast.from-wast + binaryen/test/empty_imported_table.wast.fromBinary + binaryen/test/empty_imported_table.wast.fromBinary.noDebugInfo + binaryen/test/empty_table.wast + binaryen/test/empty_table.wast.from-wast + binaryen/test/empty_table.wast.fromBinary + binaryen/test/empty_table.wast.fromBinary.noDebugInfo + binaryen/test/events.wast + binaryen/test/events.wast.from-wast + binaryen/test/events.wast.fromBinary + binaryen/test/events.wast.fromBinary.noDebugInfo + binaryen/test/example/c-api-hello-world.c + binaryen/test/example/c-api-hello-world.txt + binaryen/test/example/c-api-kitchen-sink.c + binaryen/test/example/c-api-kitchen-sink.txt + binaryen/test/example/c-api-kitchen-sink.txt.txt + binaryen/test/example/c-api-relooper-unreachable-if.cpp + binaryen/test/example/c-api-relooper-unreachable-if.txt + binaryen/test/example/c-api-unused-mem.cpp + binaryen/test/example/c-api-unused-mem.txt + binaryen/test/example/cpp-threads.cpp + binaryen/test/example/cpp-threads.txt + binaryen/test/example/cpp-unit.cpp + binaryen/test/example/cpp-unit.txt + binaryen/test/example/match.cpp + binaryen/test/example/match.txt + binaryen/test/example/relooper-fuzz.c + binaryen/test/example/relooper-fuzz.txt + binaryen/test/example/relooper-fuzz1.c + binaryen/test/example/relooper-fuzz1.txt + binaryen/test/example/relooper-fuzz2.c + binaryen/test/example/relooper-fuzz2.txt + binaryen/test/example/relooper-merge1.c + binaryen/test/example/relooper-merge1.txt + binaryen/test/example/relooper-merge2.c + binaryen/test/example/relooper-merge2.txt + binaryen/test/example/relooper-merge3.c + binaryen/test/example/relooper-merge3.txt + binaryen/test/example/relooper-merge4.c + binaryen/test/example/relooper-merge4.txt + binaryen/test/example/relooper-merge5.c + binaryen/test/example/relooper-merge5.txt + binaryen/test/example/relooper-merge6.c + binaryen/test/example/relooper-merge6.txt + binaryen/test/example/relooper-merge7.c + binaryen/test/example/relooper-merge7.txt + binaryen/test/example/small_vector.cpp + binaryen/test/example/small_vector.txt + binaryen/test/example/stack-utils.cpp + binaryen/test/example/stack-utils.txt + binaryen/test/example/typeinfo.cpp + binaryen/test/example/typeinfo.txt + binaryen/test/exception-handling.wast + binaryen/test/exception-handling.wast.from-wast + binaryen/test/exception-handling.wast.fromBinary + binaryen/test/exception-handling.wast.fromBinary.noDebugInfo + binaryen/test/export-import.wast + binaryen/test/export-import.wast.from-wast + binaryen/test/export-import.wast.fromBinary + binaryen/test/export-import.wast.fromBinary.noDebugInfo + binaryen/test/externref.wast.from-wast + binaryen/test/externref.wast.fromBinary + binaryen/test/externref.wast.fromBinary.noDebugInfo + binaryen/test/extra-unreachable.wast + binaryen/test/extra-unreachable.wast.from-wast + binaryen/test/extra-unreachable.wast.fromBinary + binaryen/test/extra-unreachable.wast.fromBinary.noDebugInfo + binaryen/test/fannkuch.args + binaryen/test/fannkuch.cpp + binaryen/test/fannkuch.txt + binaryen/test/fasta.args + binaryen/test/fasta.cpp + binaryen/test/fasta.txt + binaryen/test/fib-dbg.wasm + binaryen/test/fib-dbg.wasm.fromBinary + binaryen/test/fib-dbg.wasm.map + binaryen/test/float_ops.cpp + binaryen/test/float_ops.emcc + binaryen/test/float_ops.post.js + binaryen/test/float_ops.txt + binaryen/test/fn_prolog_epilog.debugInfo.wasm + binaryen/test/fn_prolog_epilog.debugInfo.wasm.fromBinary + binaryen/test/fn_prolog_epilog.debugInfo.wasm.map + binaryen/test/fn_prolog_epilog.debugInfo.wast + binaryen/test/fn_prolog_epilog.debugInfo.wast.from-wast + binaryen/test/fn_prolog_epilog.debugInfo.wast.fromBinary + binaryen/test/fn_prolog_epilog.debugInfo.wast.fromBinary.noDebugInfo + binaryen/test/gc.wast + binaryen/test/gc.wast.from-wast + binaryen/test/gc.wast.fromBinary + binaryen/test/gc.wast.fromBinary.noDebugInfo + binaryen/test/grow_memory.cpp + binaryen/test/grow_memory.emcc + binaryen/test/grow_memory.txt + binaryen/test/grow_memory.wast + binaryen/test/grow_memory.wast.from-wast + binaryen/test/grow_memory.wast.fromBinary + binaryen/test/grow_memory.wast.fromBinary.noDebugInfo + binaryen/test/hello_libcxx.cpp + binaryen/test/hello_libcxx.txt + binaryen/test/hello_world.asm.js + binaryen/test/hello_world.c + binaryen/test/hello_world.txt + binaryen/test/hello_world.wast.from-wast + binaryen/test/hello_world.wast.fromBinary + binaryen/test/hello_world.wast.fromBinary.noDebugInfo + binaryen/test/hello_world.wat + binaryen/test/i64-setTempRet0.asm.js + binaryen/test/imported_memory.wast + binaryen/test/imported_memory.wast.from-wast + binaryen/test/imported_memory.wast.fromBinary + binaryen/test/imported_memory.wast.fromBinary.noDebugInfo + binaryen/test/imported_memory_growth.wast + binaryen/test/imported_memory_growth.wast.from-wast + binaryen/test/imported_memory_growth.wast.fromBinary + binaryen/test/imported_memory_growth.wast.fromBinary.noDebugInfo + binaryen/test/importedSignCast.asm.js + binaryen/test/int_ops.c + binaryen/test/int_ops.emcc + binaryen/test/int_ops.post.js + binaryen/test/int_ops.txt + binaryen/test/kitchen_sink.wast + binaryen/test/kitchen_sink.wast.from-wast + binaryen/test/kitchen_sink.wast.fromBinary + binaryen/test/kitchen_sink.wast.fromBinary.noDebugInfo + binaryen/test/linker/archive/barlong.a + binaryen/test/linker/archive/foobar.a + binaryen/test/linker/bar.c + binaryen/test/linker/baz.c + binaryen/test/linker/foo.c + binaryen/test/linker/main.c + binaryen/test/linker/quux.c + binaryen/test/lld/basic_safe_stack.s + binaryen/test/lld/basic_safe_stack.wat + binaryen/test/lld/basic_safe_stack.wat.out + binaryen/test/lld/bigint.wat + binaryen/test/lld/bigint.wat.out + binaryen/test/lld/duplicate_imports.wat + binaryen/test/lld/duplicate_imports.wat.out + binaryen/test/lld/em_asm.cpp + binaryen/test/lld/em_asm.wat + binaryen/test/lld/em_asm.wat.mem.mem + binaryen/test/lld/em_asm.wat.mem.out + binaryen/test/lld/em_asm.wat.out + binaryen/test/lld/em_asm_main_thread.wat + binaryen/test/lld/em_asm_main_thread.wat.out + binaryen/test/lld/em_asm_O0.c + binaryen/test/lld/em_asm_O0.wat + binaryen/test/lld/em_asm_O0.wat.out + binaryen/test/lld/em_asm_shared.cpp + binaryen/test/lld/em_asm_shared.wat + binaryen/test/lld/em_asm_shared.wat.out + binaryen/test/lld/em_asm_table.wat + binaryen/test/lld/em_asm_table.wat.out + binaryen/test/lld/em_js_O0.wat + binaryen/test/lld/em_js_O0.wat.out + binaryen/test/lld/gdollar_mainmodule.wat + binaryen/test/lld/gdollar_mainmodule.wat.out + binaryen/test/lld/hello_world.c + binaryen/test/lld/hello_world.passive.wat + binaryen/test/lld/hello_world.passive.wat.out + binaryen/test/lld/hello_world.wat + binaryen/test/lld/hello_world.wat.mem.mem + binaryen/test/lld/hello_world.wat.mem.out + binaryen/test/lld/hello_world.wat.out + binaryen/test/lld/init.c + binaryen/test/lld/init.wat + binaryen/test/lld/init.wat.out + binaryen/test/lld/longjmp.c + binaryen/test/lld/longjmp.wat + binaryen/test/lld/longjmp.wat.out + binaryen/test/lld/main_module.wat + binaryen/test/lld/main_module.wat.out + binaryen/test/lld/main_module_table.wat + binaryen/test/lld/main_module_table.wat.out + binaryen/test/lld/main_module_table_2.wat + binaryen/test/lld/main_module_table_2.wat.out + binaryen/test/lld/main_module_table_3.wat + binaryen/test/lld/main_module_table_3.wat.out + binaryen/test/lld/main_module_table_4.wat + binaryen/test/lld/main_module_table_4.wat.out + binaryen/test/lld/main_module_table_5.wat + binaryen/test/lld/main_module_table_5.wat.out + binaryen/test/lld/recursive.c + binaryen/test/lld/recursive.wat + binaryen/test/lld/recursive.wat.out + binaryen/test/lld/recursive_safe_stack.wat + binaryen/test/lld/recursive_safe_stack.wat.out + binaryen/test/lld/reserved_func_ptr.cpp + binaryen/test/lld/reserved_func_ptr.wat + binaryen/test/lld/reserved_func_ptr.wat.out + binaryen/test/lld/safe_stack_standalone-wasm.wat + binaryen/test/lld/safe_stack_standalone-wasm.wat.out + binaryen/test/lld/shared.cpp + binaryen/test/lld/shared.wat + binaryen/test/lld/shared.wat.out + binaryen/test/lld/shared_add_to_table.wasm + binaryen/test/lld/shared_add_to_table.wasm.out + binaryen/test/lld/shared_longjmp.c + binaryen/test/lld/shared_longjmp.wat + binaryen/test/lld/shared_longjmp.wat.out + binaryen/test/lld/standalone-wasm-with-start.wat + binaryen/test/lld/standalone-wasm-with-start.wat.out + binaryen/test/lld/standalone-wasm.wat + binaryen/test/lld/standalone-wasm.wat.out + binaryen/test/lld/standalone-wasm2.wat + binaryen/test/lld/standalone-wasm2.wat.out + binaryen/test/lld/standalone-wasm3.wat + binaryen/test/lld/standalone-wasm3.wat.out + binaryen/test/mem.cpp + binaryen/test/mem.emcc + binaryen/test/mem.post.js + binaryen/test/mem.txt + binaryen/test/memory-import.wast + binaryen/test/memory-import.wast.from-wast + binaryen/test/memory-import.wast.fromBinary + binaryen/test/memory-import.wast.fromBinary.noDebugInfo + binaryen/test/memory-import64.wast + binaryen/test/memory-import64.wast.from-wast + binaryen/test/memory-import64.wast.fromBinary + binaryen/test/memory-import64.wast.fromBinary.noDebugInfo + binaryen/test/memory-import64.wast.wasm.fromBinary + binaryen/test/memory-shared.wast + binaryen/test/memory-shared.wast.from-wast + binaryen/test/memory-shared.wast.fromBinary + binaryen/test/memory-shared.wast.fromBinary.noDebugInfo + binaryen/test/memorygrowth-minimal.asm.js + binaryen/test/memorygrowth.asm.js + binaryen/test/metadatas.wasm + binaryen/test/metadatas.wasm.fromBinary + binaryen/test/metadce/all-outside.wast + binaryen/test/metadce/all-outside.wast.dced + binaryen/test/metadce/all-outside.wast.dced.stdout + binaryen/test/metadce/all-outside.wast.graph.txt + binaryen/test/metadce/corners.wast + binaryen/test/metadce/corners.wast.dced + binaryen/test/metadce/corners.wast.dced.stdout + binaryen/test/metadce/corners.wast.graph.txt + binaryen/test/metadce/no-outside.wast + binaryen/test/metadce/no-outside.wast.dced + binaryen/test/metadce/no-outside.wast.dced.stdout + binaryen/test/metadce/no-outside.wast.graph.txt + binaryen/test/metadce/outside.wast + binaryen/test/metadce/outside.wast.dced + binaryen/test/metadce/outside.wast.dced.stdout + binaryen/test/metadce/outside.wast.graph.txt + binaryen/test/metadce/rooted-export.wast + binaryen/test/metadce/rooted-export.wast.dced + binaryen/test/metadce/rooted-export.wast.dced.stdout + binaryen/test/metadce/rooted-export.wast.graph.txt + binaryen/test/metadce/spanning_cycle.wast + binaryen/test/metadce/spanning_cycle.wast.dced + binaryen/test/metadce/spanning_cycle.wast.dced.stdout + binaryen/test/metadce/spanning_cycle.wast.graph.txt + binaryen/test/metadce/spanning_cycle_unrooted.wast + binaryen/test/metadce/spanning_cycle_unrooted.wast.dced + binaryen/test/metadce/spanning_cycle_unrooted.wast.dced.stdout + binaryen/test/metadce/spanning_cycle_unrooted.wast.graph.txt + binaryen/test/metadce/threaded.wast + binaryen/test/metadce/threaded.wast.dced + binaryen/test/metadce/threaded.wast.dced.stdout + binaryen/test/metadce/threaded.wast.graph.txt + binaryen/test/metadce/threaded_cycle.wast + binaryen/test/metadce/threaded_cycle.wast.dced + binaryen/test/metadce/threaded_cycle.wast.dced.stdout + binaryen/test/metadce/threaded_cycle.wast.graph.txt + binaryen/test/metadce/threaded_unrooted.wast + binaryen/test/metadce/threaded_unrooted.wast.dced + binaryen/test/metadce/threaded_unrooted.wast.dced.stdout + binaryen/test/metadce/threaded_unrooted.wast.graph.txt + binaryen/test/metadce/threaded_unrooted_cycle.wast + binaryen/test/metadce/threaded_unrooted_cycle.wast.dced + binaryen/test/metadce/threaded_unrooted_cycle.wast.dced.stdout + binaryen/test/metadce/threaded_unrooted_cycle.wast.graph.txt + binaryen/test/min.asm.js + binaryen/test/min.wast + binaryen/test/min.wast.from-wast + binaryen/test/min.wast.fromBinary + binaryen/test/min.wast.fromBinary.noDebugInfo + binaryen/test/multivalue.wast + binaryen/test/multivalue.wast.from-wast + binaryen/test/multivalue.wast.fromBinary + binaryen/test/multivalue.wast.fromBinary.noDebugInfo + binaryen/test/mutable-global.wasm + binaryen/test/mutable-global.wasm.fromBinary + binaryen/test/mutable-global.wast + binaryen/test/mutable-global.wast.from-wast + binaryen/test/mutable-global.wast.fromBinary + binaryen/test/mutable-global.wast.fromBinary.noDebugInfo + binaryen/test/newsyntax.wast + binaryen/test/newsyntax.wast.from-wast + binaryen/test/newsyntax.wast.fromBinary + binaryen/test/newsyntax.wast.fromBinary.noDebugInfo + binaryen/test/noffi_f32.asm.js + binaryen/test/noffi_i64.asm.js + binaryen/test/nonspec-bulk-memory.wast + binaryen/test/nonspec-bulk-memory.wast.from-wast + binaryen/test/nonspec-bulk-memory.wast.fromBinary + binaryen/test/nonspec-bulk-memory.wast.fromBinary.noDebugInfo + binaryen/test/passes/alignment-lowering.txt + binaryen/test/passes/alignment-lowering.wast + binaryen/test/passes/alignment-lowering64.passes + binaryen/test/passes/alignment-lowering64.txt + binaryen/test/passes/alignment-lowering64.wast + binaryen/test/passes/asyncify.txt + binaryen/test/passes/asyncify.wast + binaryen/test/passes/asyncify_enable-multivalue.txt + binaryen/test/passes/asyncify_enable-multivalue.wast + binaryen/test/passes/asyncify_mod-asyncify-always-and-only-unwind.txt + binaryen/test/passes/asyncify_mod-asyncify-always-and-only-unwind.wast + binaryen/test/passes/asyncify_mod-asyncify-always-and-only-unwind_O.txt + binaryen/test/passes/asyncify_mod-asyncify-always-and-only-unwind_O.wast + binaryen/test/passes/asyncify_mod-asyncify-never-unwind.txt + binaryen/test/passes/asyncify_mod-asyncify-never-unwind.wast + binaryen/test/passes/asyncify_mod-asyncify-never-unwind_O.txt + binaryen/test/passes/asyncify_mod-asyncify-never-unwind_O.wast + binaryen/test/passes/asyncify_optimize-level=1.txt + binaryen/test/passes/asyncify_optimize-level=1.wast + binaryen/test/passes/asyncify_pass-arg=asyncify-addlist@foo.txt + binaryen/test/passes/asyncify_pass-arg=asyncify-addlist@foo.wast + binaryen/test/passes/asyncify_pass-arg=asyncify-addlist@foo_pass-arg=asyncify-ignore-indirect.txt + binaryen/test/passes/asyncify_pass-arg=asyncify-addlist@foo_pass-arg=asyncify-ignore-indirect.wast + binaryen/test/passes/asyncify_pass-arg=asyncify-asserts_pass-arg=asyncify-onlylist@waka.txt + binaryen/test/passes/asyncify_pass-arg=asyncify-asserts_pass-arg=asyncify-onlylist@waka.wast + "binaryen/test/passes/asyncify_pass-arg=asyncify-blacklist@foo,bar.txt" + "binaryen/test/passes/asyncify_pass-arg=asyncify-blacklist@foo,bar.wast" + binaryen/test/passes/asyncify_pass-arg=asyncify-ignore-imports.txt + binaryen/test/passes/asyncify_pass-arg=asyncify-ignore-imports.wast + binaryen/test/passes/asyncify_pass-arg=asyncify-ignore-indirect.txt + binaryen/test/passes/asyncify_pass-arg=asyncify-ignore-indirect.wast + "binaryen/test/passes/asyncify_pass-arg=asyncify-imports@env.import,env.import2.txt" + "binaryen/test/passes/asyncify_pass-arg=asyncify-imports@env.import,env.import2.wast" + "binaryen/test/passes/asyncify_pass-arg=asyncify-onlylist@foo,bar.txt" + "binaryen/test/passes/asyncify_pass-arg=asyncify-onlylist@foo,bar.wast" + binaryen/test/passes/asyncify_pass-arg=asyncify-verbose.txt + binaryen/test/passes/asyncify_pass-arg=asyncify-verbose.wast + binaryen/test/passes/avoid-reinterprets.txt + binaryen/test/passes/avoid-reinterprets.wast + binaryen/test/passes/avoid-reinterprets64.passes + binaryen/test/passes/avoid-reinterprets64.txt + binaryen/test/passes/avoid-reinterprets64.wast + binaryen/test/passes/class_with_dwarf_noprint.bin.txt + binaryen/test/passes/class_with_dwarf_noprint.passes + binaryen/test/passes/class_with_dwarf_noprint.wasm + binaryen/test/passes/coalesce-locals-learning.txt + binaryen/test/passes/coalesce-locals-learning.wast + binaryen/test/passes/coalesce-locals.txt + binaryen/test/passes/coalesce-locals.wast + binaryen/test/passes/code-folding_enable-threads.txt + binaryen/test/passes/code-folding_enable-threads.wast + binaryen/test/passes/code-pushing_all-features.txt + binaryen/test/passes/code-pushing_all-features.wast + binaryen/test/passes/code-pushing_ignore-implicit-traps.txt + binaryen/test/passes/code-pushing_ignore-implicit-traps.wast + binaryen/test/passes/const-hoisting.txt + binaryen/test/passes/const-hoisting.wast + binaryen/test/passes/converge_O3_metrics.bin.txt + binaryen/test/passes/converge_O3_metrics.wasm + binaryen/test/passes/dae-optimizing.txt + binaryen/test/passes/dae-optimizing.wast + binaryen/test/passes/dae_enable-tail-call.txt + binaryen/test/passes/dae_enable-tail-call.wast + binaryen/test/passes/dce_all-features.txt + binaryen/test/passes/dce_all-features.wast + binaryen/test/passes/dce_vacuum.bin.txt + binaryen/test/passes/dce_vacuum.txt + binaryen/test/passes/dce_vacuum.wasm + binaryen/test/passes/dce_vacuum.wast + binaryen/test/passes/dealign.txt + binaryen/test/passes/dealign.wast + binaryen/test/passes/dealign64.passes + binaryen/test/passes/dealign64.txt + binaryen/test/passes/dealign64.wast + binaryen/test/passes/denan.txt + binaryen/test/passes/denan.wast + binaryen/test/passes/directize_enable-tail-call.txt + binaryen/test/passes/directize_enable-tail-call.wast + binaryen/test/passes/duplicate-function-elimination_all-features.txt + binaryen/test/passes/duplicate-function-elimination_all-features.wast + binaryen/test/passes/duplicate-function-elimination_optimize-level=1.txt + binaryen/test/passes/duplicate-function-elimination_optimize-level=1.wast + binaryen/test/passes/duplicate-function-elimination_optimize-level=2.txt + binaryen/test/passes/duplicate-function-elimination_optimize-level=2.wast + binaryen/test/passes/duplicate-import-elimination.txt + binaryen/test/passes/duplicate-import-elimination.wast + binaryen/test/passes/dwarf-local-order.bin.txt + binaryen/test/passes/dwarf-local-order.passes + binaryen/test/passes/dwarf-local-order.wasm + binaryen/test/passes/dwarf_unit_with_no_abbrevs_noprint.bin.txt + binaryen/test/passes/dwarf_unit_with_no_abbrevs_noprint.passes + binaryen/test/passes/dwarf_unit_with_no_abbrevs_noprint.wasm + binaryen/test/passes/dwarfdump.bin.txt + binaryen/test/passes/dwarfdump.wasm + binaryen/test/passes/dwarfdump_roundtrip_dwarfdump.bin.txt + binaryen/test/passes/dwarfdump_roundtrip_dwarfdump.wasm + binaryen/test/passes/emit-js-wrapper=a.js.txt + binaryen/test/passes/emit-js-wrapper=a.js.wast + binaryen/test/passes/emit-js-wrapper=a.js.wast.js + binaryen/test/passes/emit-spec-wrapper=a.wat.txt + binaryen/test/passes/emit-spec-wrapper=a.wat.wast + binaryen/test/passes/emit-spec-wrapper=a.wat.wast.wat + binaryen/test/passes/extract-function_pass-arg=extract@foo.txt + binaryen/test/passes/extract-function_pass-arg=extract@foo.wast + binaryen/test/passes/fannkuch0_dwarf.bin.txt + binaryen/test/passes/fannkuch0_dwarf.passes + binaryen/test/passes/fannkuch0_dwarf.wasm + binaryen/test/passes/fannkuch3_dwarf.bin.txt + binaryen/test/passes/fannkuch3_dwarf.passes + binaryen/test/passes/fannkuch3_dwarf.wasm + binaryen/test/passes/fannkuch3_manyopts_dwarf.bin.txt + binaryen/test/passes/fannkuch3_manyopts_dwarf.passes + binaryen/test/passes/fannkuch3_manyopts_dwarf.wasm + binaryen/test/passes/fib2_dwarf.bin.txt + binaryen/test/passes/fib2_dwarf.passes + binaryen/test/passes/fib2_dwarf.wasm + binaryen/test/passes/fib2_emptylocspan_dwarf.bin.txt + binaryen/test/passes/fib2_emptylocspan_dwarf.passes + binaryen/test/passes/fib2_emptylocspan_dwarf.wasm + binaryen/test/passes/fib_nonzero-low-pc_dwarf.bin.txt + binaryen/test/passes/fib_nonzero-low-pc_dwarf.passes + binaryen/test/passes/fib_nonzero-low-pc_dwarf.wasm + binaryen/test/passes/flatten.bin.txt + binaryen/test/passes/flatten.wasm + binaryen/test/passes/flatten_all-features.txt + binaryen/test/passes/flatten_all-features.wast + binaryen/test/passes/flatten_dfo_O3_enable-threads.txt + binaryen/test/passes/flatten_dfo_O3_enable-threads.wast + binaryen/test/passes/flatten_i64-to-i32-lowering.txt + binaryen/test/passes/flatten_i64-to-i32-lowering.wast + binaryen/test/passes/flatten_local-cse_all-features.txt + binaryen/test/passes/flatten_local-cse_all-features.wast + binaryen/test/passes/flatten_local-cse_Os.txt + binaryen/test/passes/flatten_local-cse_Os.wast + binaryen/test/passes/flatten_rereloop.txt + binaryen/test/passes/flatten_rereloop.wast + binaryen/test/passes/flatten_simplify-locals-nonesting_dfo_O3.txt + binaryen/test/passes/flatten_simplify-locals-nonesting_dfo_O3.wast + binaryen/test/passes/flatten_simplify-locals-nonesting_souperify-single-use_enable-threads.txt + binaryen/test/passes/flatten_simplify-locals-nonesting_souperify-single-use_enable-threads.wast + binaryen/test/passes/flatten_simplify-locals-nonesting_souperify_enable-threads.txt + binaryen/test/passes/flatten_simplify-locals-nonesting_souperify_enable-threads.wast + binaryen/test/passes/fpcast-emu.txt + binaryen/test/passes/fpcast-emu.wast + binaryen/test/passes/func-metrics.txt + binaryen/test/passes/func-metrics.wast + binaryen/test/passes/fuzz-exec_all-features.txt + binaryen/test/passes/fuzz-exec_all-features.wast + binaryen/test/passes/fuzz-exec_O.txt + binaryen/test/passes/fuzz-exec_O.wast + binaryen/test/passes/fuzz_metrics_noprint.bin.txt + binaryen/test/passes/fuzz_metrics_noprint.passes + binaryen/test/passes/fuzz_metrics_noprint.wasm + binaryen/test/passes/generate-dyncalls.txt + binaryen/test/passes/generate-dyncalls.wast + binaryen/test/passes/generate-i64-dyncalls.txt + binaryen/test/passes/generate-i64-dyncalls.wast + binaryen/test/passes/generate-stack-ir_optimize-stack-ir_print-stack-ir_all-features.txt + binaryen/test/passes/generate-stack-ir_optimize-stack-ir_print-stack-ir_all-features.wast + binaryen/test/passes/generate-stack-ir_optimize-stack-ir_print-stack-ir_optimize-level=3.txt + binaryen/test/passes/generate-stack-ir_optimize-stack-ir_print-stack-ir_optimize-level=3.wast + binaryen/test/passes/ignore_missing_func_dwarf.bin.txt + binaryen/test/passes/ignore_missing_func_dwarf.passes + binaryen/test/passes/ignore_missing_func_dwarf.wasm + binaryen/test/passes/inline-main.txt + binaryen/test/passes/inline-main.wast + binaryen/test/passes/inlined_to_start_dwarf.bin.txt + binaryen/test/passes/inlined_to_start_dwarf.passes + binaryen/test/passes/inlined_to_start_dwarf.wasm + binaryen/test/passes/inlining-optimizing_enable-threads.txt + binaryen/test/passes/inlining-optimizing_enable-threads.wast + binaryen/test/passes/inlining-optimizing_optimize-level=3.txt + binaryen/test/passes/inlining-optimizing_optimize-level=3.wast + binaryen/test/passes/inlining_all-features.txt + binaryen/test/passes/inlining_all-features.wast + binaryen/test/passes/inlining_enable-tail-call.txt + binaryen/test/passes/inlining_enable-tail-call.wast + binaryen/test/passes/inlining_optimize-level=3.txt + binaryen/test/passes/inlining_optimize-level=3.wast + binaryen/test/passes/instrument-locals_all-features.txt + binaryen/test/passes/instrument-locals_all-features.wast + binaryen/test/passes/instrument-memory.txt + binaryen/test/passes/instrument-memory.wast + binaryen/test/passes/instrument-memory64.passes + binaryen/test/passes/instrument-memory64.txt + binaryen/test/passes/instrument-memory64.wast + binaryen/test/passes/interesting-pass-mix.passes + binaryen/test/passes/interesting-pass-mix.txt + binaryen/test/passes/interesting-pass-mix.wast + binaryen/test/passes/legalize-js-interface-minimally.txt + binaryen/test/passes/legalize-js-interface-minimally.wast + binaryen/test/passes/legalize-js-interface_all-features.txt + binaryen/test/passes/legalize-js-interface_all-features.wast + binaryen/test/passes/legalize-js-interface_pass-arg=legalize-js-interface-export-originals.txt + binaryen/test/passes/legalize-js-interface_pass-arg=legalize-js-interface-export-originals.wast + binaryen/test/passes/licm.txt + binaryen/test/passes/licm.wast + binaryen/test/passes/limit-segments_disable-bulk-memory.txt + binaryen/test/passes/limit-segments_disable-bulk-memory.wast + binaryen/test/passes/log-execution.txt + binaryen/test/passes/log-execution.wast + binaryen/test/passes/memory-packing_all-features.txt + binaryen/test/passes/memory-packing_all-features.wast + binaryen/test/passes/merge-blocks.txt + binaryen/test/passes/merge-blocks.wast + binaryen/test/passes/merge-blocks_remove-unused-brs.txt + binaryen/test/passes/merge-blocks_remove-unused-brs.wast + binaryen/test/passes/merge-locals_all-features.txt + binaryen/test/passes/merge-locals_all-features.wast + binaryen/test/passes/metrics_all-features.txt + binaryen/test/passes/metrics_all-features.wast + binaryen/test/passes/metrics_strip-debug_metrics.bin.txt + binaryen/test/passes/metrics_strip-debug_metrics.wasm + binaryen/test/passes/metrics_strip-producers_metrics.bin.txt + binaryen/test/passes/metrics_strip-producers_metrics.wasm + binaryen/test/passes/minify-imports-and-exports-and-modules.txt + binaryen/test/passes/minify-imports-and-exports-and-modules.wast + binaryen/test/passes/minify-imports-and-exports_all-features.txt + binaryen/test/passes/minify-imports-and-exports_all-features.wast + binaryen/test/passes/minify-imports_all-features.txt + binaryen/test/passes/minify-imports_all-features.wast + binaryen/test/passes/multi_line_table_dwarf.bin.txt + binaryen/test/passes/multi_line_table_dwarf.passes + binaryen/test/passes/multi_line_table_dwarf.wasm + binaryen/test/passes/multi_unit_abbrev_noprint.bin.txt + binaryen/test/passes/multi_unit_abbrev_noprint.passes + binaryen/test/passes/multi_unit_abbrev_noprint.wasm + binaryen/test/passes/nm.txt + binaryen/test/passes/nm.wast + binaryen/test/passes/no-exit-runtime.txt + binaryen/test/passes/no-exit-runtime.wast + binaryen/test/passes/O.bin.txt + binaryen/test/passes/O.txt + binaryen/test/passes/O.wasm + binaryen/test/passes/O.wast + binaryen/test/passes/O1.txt + binaryen/test/passes/O1.wast + binaryen/test/passes/O1_print-stack-ir.txt + binaryen/test/passes/O1_print-stack-ir.wast + binaryen/test/passes/O2_precompute-propagate_print-stack-ir.txt + binaryen/test/passes/O2_precompute-propagate_print-stack-ir.wast + binaryen/test/passes/O2_print-stack-ir.txt + binaryen/test/passes/O2_print-stack-ir.wast + binaryen/test/passes/O3_inline-functions-with-loops_flexible-inline-max-function-size=30.txt + binaryen/test/passes/O3_inline-functions-with-loops_flexible-inline-max-function-size=30.wast + binaryen/test/passes/O3_inlining.txt + binaryen/test/passes/O3_inlining.wast + binaryen/test/passes/O3_low-memory-unused_metrics.txt + binaryen/test/passes/O3_low-memory-unused_metrics.wast + binaryen/test/passes/O3_print-stack-ir.txt + binaryen/test/passes/O3_print-stack-ir.wast + binaryen/test/passes/O4_disable-bulk-memory.txt + binaryen/test/passes/O4_disable-bulk-memory.wast + binaryen/test/passes/O_fast-math.txt + binaryen/test/passes/O_fast-math.wast + binaryen/test/passes/optimize-added-constants-propagate_low-memory-unused.txt + binaryen/test/passes/optimize-added-constants-propagate_low-memory-unused.wast + binaryen/test/passes/optimize-added-constants_low-memory-unused.txt + binaryen/test/passes/optimize-added-constants_low-memory-unused.wast + binaryen/test/passes/optimize-instructions_all-features.txt + binaryen/test/passes/optimize-instructions_all-features.wast + binaryen/test/passes/optimize-instructions_optimize-level=2_all-features_ignore-implicit-traps.txt + binaryen/test/passes/optimize-instructions_optimize-level=2_all-features_ignore-implicit-traps.wast + binaryen/test/passes/Os_print-stack-ir_all-features.txt + binaryen/test/passes/Os_print-stack-ir_all-features.wast + binaryen/test/passes/Oz.txt + binaryen/test/passes/Oz.wast + binaryen/test/passes/pick-load-signs.txt + binaryen/test/passes/pick-load-signs.wast + binaryen/test/passes/post-assemblyscript-finalize.txt + binaryen/test/passes/post-assemblyscript-finalize.wast + binaryen/test/passes/post-assemblyscript.txt + binaryen/test/passes/post-assemblyscript.wast + binaryen/test/passes/post-emscripten.txt + binaryen/test/passes/post-emscripten.wast + binaryen/test/passes/precompute-propagate_all-features.txt + binaryen/test/passes/precompute-propagate_all-features.wast + binaryen/test/passes/precompute_all-features.txt + binaryen/test/passes/precompute_all-features.wast + binaryen/test/passes/precompute_coalesce-locals_vacuum.txt + binaryen/test/passes/precompute_coalesce-locals_vacuum.wast + binaryen/test/passes/print-call-graph.txt + binaryen/test/passes/print-call-graph.wast + binaryen/test/passes/print-function-map.txt + binaryen/test/passes/print-function-map.wast + binaryen/test/passes/print.bin.txt + binaryen/test/passes/print.wasm + binaryen/test/passes/print_g.bin.txt + binaryen/test/passes/print_g.wasm + binaryen/test/passes/print_g_metrics.bin.txt + binaryen/test/passes/print_g_metrics.wasm + binaryen/test/passes/print_g_strip-dwarf.bin.txt + binaryen/test/passes/print_g_strip-dwarf.wasm + binaryen/test/passes/remove-imports.txt + binaryen/test/passes/remove-imports.wast + binaryen/test/passes/remove-memory.txt + binaryen/test/passes/remove-memory.wast + binaryen/test/passes/remove-non-js-ops.txt + binaryen/test/passes/remove-non-js-ops.wast + binaryen/test/passes/remove-unused-brs_enable-multivalue.txt + binaryen/test/passes/remove-unused-brs_enable-multivalue.wast + binaryen/test/passes/remove-unused-brs_generate-stack-ir_print-stack-ir.txt + binaryen/test/passes/remove-unused-brs_generate-stack-ir_print-stack-ir.wast + binaryen/test/passes/remove-unused-brs_precompute_vacuum_remove-unused-brs.txt + binaryen/test/passes/remove-unused-brs_precompute_vacuum_remove-unused-brs.wast + binaryen/test/passes/remove-unused-brs_shrink-level=1.txt + binaryen/test/passes/remove-unused-brs_shrink-level=1.wast + binaryen/test/passes/remove-unused-brs_shrink-level=1_ignore-implicit-traps.txt + binaryen/test/passes/remove-unused-brs_shrink-level=1_ignore-implicit-traps.wast + binaryen/test/passes/remove-unused-module-elements_all-features.txt + binaryen/test/passes/remove-unused-module-elements_all-features.wast + binaryen/test/passes/remove-unused-names.txt + binaryen/test/passes/remove-unused-names.wast + binaryen/test/passes/remove-unused-names_code-folding_all-features.txt + binaryen/test/passes/remove-unused-names_code-folding_all-features.wast + binaryen/test/passes/remove-unused-names_merge-blocks_all-features.txt + binaryen/test/passes/remove-unused-names_merge-blocks_all-features.wast + binaryen/test/passes/remove-unused-names_optimize-instructions_all-features.txt + binaryen/test/passes/remove-unused-names_optimize-instructions_all-features.wast + binaryen/test/passes/remove-unused-names_precompute.txt + binaryen/test/passes/remove-unused-names_precompute.wast + binaryen/test/passes/remove-unused-names_remove-unused-brs_vacuum.txt + binaryen/test/passes/remove-unused-names_remove-unused-brs_vacuum.wast + binaryen/test/passes/remove-unused-names_vacuum.txt + binaryen/test/passes/remove-unused-names_vacuum.wast + binaryen/test/passes/remove-unused-names_vacuum_ignore-implicit-traps.txt + binaryen/test/passes/remove-unused-names_vacuum_ignore-implicit-traps.wast + binaryen/test/passes/remove-unused-nonfunction-module-elements_all-features.txt + binaryen/test/passes/remove-unused-nonfunction-module-elements_all-features.wast + binaryen/test/passes/reorder-functions.txt + binaryen/test/passes/reorder-functions.wast + binaryen/test/passes/reorder-locals.txt + binaryen/test/passes/reorder-locals.wast + binaryen/test/passes/reverse_dwarf_abbrevs.bin.txt + binaryen/test/passes/reverse_dwarf_abbrevs.passes + binaryen/test/passes/reverse_dwarf_abbrevs.wasm + binaryen/test/passes/roundtrip.txt + binaryen/test/passes/roundtrip.wast + binaryen/test/passes/rse_all-features.txt + binaryen/test/passes/rse_all-features.wast + binaryen/test/passes/safe-heap_disable-simd.txt + binaryen/test/passes/safe-heap_disable-simd.wast + binaryen/test/passes/safe-heap_enable-threads_enable-simd.txt + binaryen/test/passes/safe-heap_enable-threads_enable-simd.wast + binaryen/test/passes/safe-heap_enable-threads_enable-simd64.passes + binaryen/test/passes/safe-heap_enable-threads_enable-simd64.txt + binaryen/test/passes/safe-heap_enable-threads_enable-simd64.wast + binaryen/test/passes/safe-heap_low-memory-unused_enable-threads_enable-simd.txt + binaryen/test/passes/safe-heap_low-memory-unused_enable-threads_enable-simd.wast + binaryen/test/passes/simplify-globals-optimizing_enable-mutable-globals.txt + binaryen/test/passes/simplify-globals-optimizing_enable-mutable-globals.wast + binaryen/test/passes/simplify-globals_all-features.txt + binaryen/test/passes/simplify-globals_all-features.wast + binaryen/test/passes/simplify-locals-nonesting.txt + binaryen/test/passes/simplify-locals-nonesting.wast + binaryen/test/passes/simplify-locals-nostructure.txt + binaryen/test/passes/simplify-locals-nostructure.wast + binaryen/test/passes/simplify-locals-notee-nostructure.txt + binaryen/test/passes/simplify-locals-notee-nostructure.wast + binaryen/test/passes/simplify-locals-notee.txt + binaryen/test/passes/simplify-locals-notee.wast + binaryen/test/passes/simplify-locals.txt + binaryen/test/passes/simplify-locals.wast + binaryen/test/passes/simplify-locals_all-features.txt + binaryen/test/passes/simplify-locals_all-features.wast + binaryen/test/passes/simplify-locals_all-features_disable-exception-handling.txt + binaryen/test/passes/simplify-locals_all-features_disable-exception-handling.wast + binaryen/test/passes/souperify.txt + binaryen/test/passes/souperify.wast + binaryen/test/passes/spill-pointers.txt + binaryen/test/passes/spill-pointers.wast + binaryen/test/passes/ssa-nomerge_enable-simd.txt + binaryen/test/passes/ssa-nomerge_enable-simd.wast + binaryen/test/passes/ssa_enable-threads.txt + binaryen/test/passes/ssa_enable-threads.wast + binaryen/test/passes/ssa_fuzz-exec_enable-threads.txt + binaryen/test/passes/ssa_fuzz-exec_enable-threads.wast + binaryen/test/passes/stack-check_enable-mutable-globals.txt + binaryen/test/passes/stack-check_enable-mutable-globals.wast + binaryen/test/passes/strip-debug.bin.txt + binaryen/test/passes/strip-debug.wasm + binaryen/test/passes/strip-dwarf.bin.txt + binaryen/test/passes/strip-dwarf.wasm + binaryen/test/passes/strip-producers.bin.txt + binaryen/test/passes/strip-producers.wasm + binaryen/test/passes/strip-target-features.bin.txt + binaryen/test/passes/strip-target-features.wasm + binaryen/test/passes/strip-target-features_roundtrip_print-features_all-features.txt + binaryen/test/passes/strip-target-features_roundtrip_print-features_all-features.wast + binaryen/test/passes/stub-unsupported-js.txt + binaryen/test/passes/stub-unsupported-js.wast + binaryen/test/passes/too_much_for_liveness.bin.txt + binaryen/test/passes/too_much_for_liveness.passes + binaryen/test/passes/too_much_for_liveness.wasm + binaryen/test/passes/translate-to-fuzz_all-features.txt + binaryen/test/passes/translate-to-fuzz_all-features.wast + binaryen/test/passes/trap-mode-clamp.txt + binaryen/test/passes/trap-mode-clamp.wast + binaryen/test/passes/trap-mode-js.txt + binaryen/test/passes/trap-mode-js.wast + binaryen/test/passes/untee.txt + binaryen/test/passes/untee.wast + binaryen/test/passes/vacuum_all-features.txt + binaryen/test/passes/vacuum_all-features.wast + binaryen/test/passes/vacuum_ignore-implicit-traps.txt + binaryen/test/passes/vacuum_ignore-implicit-traps.wast + binaryen/test/passes/vacuum_remove-unused-names_merge-blocks.txt + binaryen/test/passes/vacuum_remove-unused-names_merge-blocks.wast + binaryen/test/polymorphic_stack.wast + binaryen/test/polymorphic_stack.wast.from-wast + binaryen/test/polymorphic_stack.wast.fromBinary + binaryen/test/polymorphic_stack.wast.fromBinary.noDebugInfo + binaryen/test/print/memory-import-shared.minified.txt + binaryen/test/print/memory-import-shared.txt + binaryen/test/print/memory-import-shared.wast + binaryen/test/print/memory-shared.minified.txt + binaryen/test/print/memory-shared.txt + binaryen/test/print/memory-shared.wast + binaryen/test/print/min.minified.txt + binaryen/test/print/min.txt + binaryen/test/print/min.wast + binaryen/test/printf.c + binaryen/test/printf.txt + binaryen/test/reduce/destructive.wast + binaryen/test/reduce/destructive.wast.txt + binaryen/test/reduce/imports.wast + binaryen/test/reduce/imports.wast.txt + binaryen/test/reduce/memory_table.wast + binaryen/test/reduce/memory_table.wast.txt + binaryen/test/reduce/simple.wast + binaryen/test/reduce/simple.wast.txt + binaryen/test/reference-types.wast + binaryen/test/reference-types.wast.from-wast + binaryen/test/reference-types.wast.fromBinary + binaryen/test/reference-types.wast.fromBinary.noDebugInfo + binaryen/test/reg_switch.wast + binaryen/test/reg_switch.wast.from-wast + binaryen/test/reg_switch.wast.fromBinary + binaryen/test/reg_switch.wast.fromBinary.noDebugInfo + binaryen/test/revision + binaryen/test/segment-overlap.wast + binaryen/test/segment-overlap.wast.from-wast + binaryen/test/segment-overlap.wast.fromBinary + binaryen/test/segment-overlap.wast.fromBinary.noDebugInfo + binaryen/test/signext.wast + binaryen/test/signext.wast.from-wast + binaryen/test/signext.wast.fromBinary + binaryen/test/signext.wast.fromBinary.noDebugInfo + binaryen/test/simd.wast + binaryen/test/simd.wast.from-wast + binaryen/test/simd.wast.fromBinary + binaryen/test/simd.wast.fromBinary.noDebugInfo + binaryen/test/simd64.wast + binaryen/test/simd64.wast.from-wast + binaryen/test/simd64.wast.fromBinary + binaryen/test/simd64.wast.fromBinary.noDebugInfo + binaryen/test/spec/address-offset-range.fail.wast + binaryen/test/spec/address.wast + binaryen/test/spec/address64.wast + binaryen/test/spec/align.wast + binaryen/test/spec/align64.wast + binaryen/test/spec/atomics.wast + binaryen/test/spec/binary-leb128.wast + binaryen/test/spec/binary.wast + binaryen/test/spec/block.wast + binaryen/test/spec/br.wast + binaryen/test/spec/br_if.wast + binaryen/test/spec/br_table.wast + binaryen/test/spec/break-drop.wast + binaryen/test/spec/bulk-memory.wast + binaryen/test/spec/bulk-memory64.wast + binaryen/test/spec/call.wast + binaryen/test/spec/call_indirect.wast + binaryen/test/spec/call_indirect_sig_mismatch.wast + binaryen/test/spec/comments.wast + binaryen/test/spec/const.wast + binaryen/test/spec/Contributing.md + binaryen/test/spec/conversions.wast + binaryen/test/spec/custom.wast + binaryen/test/spec/data.wast + binaryen/test/spec/elem.wast + binaryen/test/spec/endianness.wast + binaryen/test/spec/endianness64.wast + binaryen/test/spec/events.wast + binaryen/test/spec/exception-handling.wast + binaryen/test/spec/expected-output/func_ptrs.wast.log + binaryen/test/spec/expected-output/names.wast.log + binaryen/test/spec/expected-output/old_imports.wast.log + binaryen/test/spec/expected-output/old_start.wast.log + binaryen/test/spec/exports.wast + binaryen/test/spec/f32.load32.fail.wast + binaryen/test/spec/f32.load64.fail.wast + binaryen/test/spec/f32.store32.fail.wast + binaryen/test/spec/f32.store64.fail.wast + binaryen/test/spec/f32.wast + binaryen/test/spec/f32_bitwise.wast + binaryen/test/spec/f32_cmp.wast + binaryen/test/spec/f64.load32.fail.wast + binaryen/test/spec/f64.load64.fail.wast + binaryen/test/spec/f64.store32.fail.wast + binaryen/test/spec/f64.store64.fail.wast + binaryen/test/spec/f64.wast + binaryen/test/spec/f64_bitwise.wast + binaryen/test/spec/f64_cmp.wast + binaryen/test/spec/fac.wast + binaryen/test/spec/float_exprs.wast + binaryen/test/spec/float_literals.wast + binaryen/test/spec/float_memory.wast + binaryen/test/spec/float_memory64.wast + binaryen/test/spec/float_misc.wast + binaryen/test/spec/forward.wast + binaryen/test/spec/func-local-after-body.fail.wast + binaryen/test/spec/func-local-before-param.fail.wast + binaryen/test/spec/func-local-before-result.fail.wast + binaryen/test/spec/func-param-after-body.fail.wast + binaryen/test/spec/func-result-after-body.fail.wast + binaryen/test/spec/func-result-before-param.fail.wast + binaryen/test/spec/func.wast + binaryen/test/spec/func_ptrs.wast + binaryen/test/spec/get_local.wast + binaryen/test/spec/globals.wast + binaryen/test/spec/i32.load32_s.fail.wast + binaryen/test/spec/i32.load32_u.fail.wast + binaryen/test/spec/i32.load64_s.fail.wast + binaryen/test/spec/i32.load64_u.fail.wast + binaryen/test/spec/i32.store32.fail.wast + binaryen/test/spec/i32.store64.fail.wast + binaryen/test/spec/i32.wast + binaryen/test/spec/i64.load64_s.fail.wast + binaryen/test/spec/i64.load64_u.fail.wast + binaryen/test/spec/i64.store64.fail.wast + binaryen/test/spec/i64.wast + binaryen/test/spec/if.wast + binaryen/test/spec/import-after-func.fail.wast + binaryen/test/spec/import-after-global.fail.wast + binaryen/test/spec/import-after-memory.fail.wast + binaryen/test/spec/import-after-table.fail.wast + binaryen/test/spec/imports.wast + binaryen/test/spec/inline-module.wast + binaryen/test/spec/int_exprs.wast + binaryen/test/spec/int_literals.wast + binaryen/test/spec/labels.wast + binaryen/test/spec/left-to-right.wast + binaryen/test/spec/LICENSE + binaryen/test/spec/linking.wast + binaryen/test/spec/load.wast + binaryen/test/spec/load64.wast + binaryen/test/spec/local_get.wast + binaryen/test/spec/local_set.wast + binaryen/test/spec/local_tee.wast + binaryen/test/spec/loop.wast + binaryen/test/spec/memory.wast + binaryen/test/spec/memory64.wast + binaryen/test/spec/memory_grow.wast + binaryen/test/spec/memory_grow64.wast + binaryen/test/spec/memory_redundancy.wast + binaryen/test/spec/memory_redundancy64.wast + binaryen/test/spec/memory_size.wast + binaryen/test/spec/memory_trap.wast + binaryen/test/spec/memory_trap64.wast + binaryen/test/spec/multivalue.wast + binaryen/test/spec/names.wast + binaryen/test/spec/nop.wast + binaryen/test/spec/of_string-overflow-hex-u32.fail.wast + binaryen/test/spec/of_string-overflow-hex-u64.fail.wast + binaryen/test/spec/of_string-overflow-s32.fail.wast + binaryen/test/spec/of_string-overflow-s64.fail.wast + binaryen/test/spec/of_string-overflow-u32.fail.wast + binaryen/test/spec/of_string-overflow-u64.fail.wast + binaryen/test/spec/old_address.wast + binaryen/test/spec/old_address64.wast + binaryen/test/spec/old_block.wast + binaryen/test/spec/old_br_if.wast + binaryen/test/spec/old_call.wast + binaryen/test/spec/old_call_indirect.wast + binaryen/test/spec/old_exports.wast + binaryen/test/spec/old_float_exprs.wast + binaryen/test/spec/old_float_literals.wast + binaryen/test/spec/old_func.wast + binaryen/test/spec/old_globals.wast + binaryen/test/spec/old_import.wast + binaryen/test/spec/old_int_literals.wast + binaryen/test/spec/old_loop.wast + binaryen/test/spec/old_select.wast + binaryen/test/spec/old_start.wast + binaryen/test/spec/old_unreachable.wast + binaryen/test/spec/README.md + binaryen/test/spec/ref_func.wast + binaryen/test/spec/ref_is_null.wast + binaryen/test/spec/ref_null.wast + binaryen/test/spec/resizing.wast + binaryen/test/spec/resizing64.wast + binaryen/test/spec/return.wast + binaryen/test/spec/run.py + binaryen/test/spec/select.wast + binaryen/test/spec/set_local.wast + binaryen/test/spec/simd.wast + binaryen/test/spec/skip-stack-guard-page.wast + binaryen/test/spec/stack.wast + binaryen/test/spec/start.wast + binaryen/test/spec/store.wast + binaryen/test/spec/store_retval.wast + binaryen/test/spec/switch.wast + binaryen/test/spec/tee_local.wast + binaryen/test/spec/token.wast + binaryen/test/spec/traps.wast + binaryen/test/spec/type.wast + binaryen/test/spec/typecheck.wast + binaryen/test/spec/unreachable.wast + binaryen/test/spec/unreached-invalid.wast + binaryen/test/spec/unwind.wast + binaryen/test/spec/utf8-custom-section-id.wast + binaryen/test/spec/utf8-import-field.wast + binaryen/test/spec/utf8-import-module.wast + binaryen/test/spec/utf8-invalid-encoding.wast + binaryen/test/stacky.wasm + binaryen/test/stacky.wasm.fromBinary + binaryen/test/table-import.wast + binaryen/test/table-import.wast.from-wast + binaryen/test/table-import.wast.fromBinary + binaryen/test/table-import.wast.fromBinary.noDebugInfo + binaryen/test/tail-call.wast + binaryen/test/tail-call.wast.from-wast + binaryen/test/tail-call.wast.fromBinary + binaryen/test/tail-call.wast.fromBinary.noDebugInfo + binaryen/test/threads.asm.js + binaryen/test/threads.wasm-only.asm.js + binaryen/test/try-body-multiple-insts.wasm + binaryen/test/try-body-multiple-insts.wasm.fromBinary + binaryen/test/two_sides.asm.js + binaryen/test/unit.asm.js + binaryen/test/unit.wast.from-wast + binaryen/test/unit.wast.fromBinary + binaryen/test/unit.wast.fromBinary.noDebugInfo + binaryen/test/unit.wat + binaryen/test/unit/__init__.py + binaryen/test/unit/input/asyncify-coroutine.wat + binaryen/test/unit/input/asyncify-pure.txt + binaryen/test/unit/input/asyncify-pure.wat + binaryen/test/unit/input/asyncify-sleep.wat + binaryen/test/unit/input/asyncify-stackOverflow.wat + binaryen/test/unit/input/asyncify.js + binaryen/test/unit/input/atomics_target_feature.wasm + binaryen/test/unit/input/bulkmem_bad_datacount.wasm + binaryen/test/unit/input/bulkmem_data.wasm + binaryen/test/unit/input/bulkmem_target_feature.wasm + binaryen/test/unit/input/dwarf/cubescript.wasm + binaryen/test/unit/input/dwarf/zlib.wasm + binaryen/test/unit/input/em_asm_mangled_string.wat + binaryen/test/unit/input/empty.wasm + binaryen/test/unit/input/empty_lld.wat + binaryen/test/unit/input/exception_handling_target_feature.wasm + binaryen/test/unit/input/gc_target_feature.wasm + binaryen/test/unit/input/mutable_globals_target_feature.wasm + binaryen/test/unit/input/reference_types_target_feature.wasm + binaryen/test/unit/input/signext_target_feature.wasm + binaryen/test/unit/input/simd_target_feature.wasm + binaryen/test/unit/input/stack_ir.wat + binaryen/test/unit/input/tail_call_target_feature.wasm + binaryen/test/unit/input/truncsat_target_feature.wasm + binaryen/test/unit/input/update.sh + binaryen/test/unit/test_asyncify.py + binaryen/test/unit/test_datacount.py + binaryen/test/unit/test_dwarf.py + binaryen/test/unit/test_errors.py + binaryen/test/unit/test_features.py + binaryen/test/unit/test_finalize.py + binaryen/test/unit/test_memory_packing.py + binaryen/test/unit/test_poppy_validation.py + binaryen/test/unit/test_stack_ir.py + binaryen/test/unit/test_tail_call_type.py + binaryen/test/unit/test_warnings.py + binaryen/test/unit/test_wasm2c.py + binaryen/test/unit/utils.py + binaryen/test/unreachable-code.wast + binaryen/test/unreachable-code.wast.from-wast + binaryen/test/unreachable-code.wast.fromBinary + binaryen/test/unreachable-code.wast.fromBinary.noDebugInfo + binaryen/test/unreachable-import_wasm-only.asm.js + binaryen/test/unreachable-instr-type.wast + binaryen/test/unreachable-instr-type.wast.from-wast + binaryen/test/unreachable-instr-type.wast.fromBinary + binaryen/test/unreachable-instr-type.wast.fromBinary.noDebugInfo + binaryen/test/unreachable-pops.wasm + binaryen/test/unreachable-pops.wasm.fromBinary + binaryen/test/untaken-br_if.wast + binaryen/test/untaken-br_if.wast.from-wast + binaryen/test/untaken-br_if.wast.fromBinary + binaryen/test/untaken-br_if.wast.fromBinary.noDebugInfo + binaryen/test/use-import-and-drop.asm.js + binaryen/test/validator/invalid_export.wast + binaryen/test/validator/invalid_import.wast + binaryen/test/validator/invalid_number.wast + binaryen/test/validator/invalid_return.wast + binaryen/test/wasm-only.asm.js + binaryen/test/wasm2asm.asserts.js + binaryen/test/wasm2asm.traps.js + binaryen/test/wasm2js.asserts.js + binaryen/test/wasm2js.traps.js + binaryen/test/wasm2js/add_div.2asm.js + binaryen/test/wasm2js/add_div.2asm.js.opt + binaryen/test/wasm2js/add_div.wast + binaryen/test/wasm2js/atomic_fence.2asm.js + binaryen/test/wasm2js/atomic_fence.2asm.js.opt + binaryen/test/wasm2js/atomic_fence.wast + binaryen/test/wasm2js/atomics_32.2asm.js + binaryen/test/wasm2js/atomics_32.2asm.js.opt + binaryen/test/wasm2js/atomics_32.wast + binaryen/test/wasm2js/base64.2asm.js + binaryen/test/wasm2js/base64.2asm.js.opt + binaryen/test/wasm2js/base64.wast + binaryen/test/wasm2js/br.2asm.js + binaryen/test/wasm2js/br_table.2asm.js + binaryen/test/wasm2js/br_table_hoisting.2asm.js + binaryen/test/wasm2js/br_table_hoisting.2asm.js.opt + binaryen/test/wasm2js/br_table_hoisting.wast + binaryen/test/wasm2js/br_table_temp.2asm.js + binaryen/test/wasm2js/br_table_temp.2asm.js.opt + binaryen/test/wasm2js/br_table_temp.wast + binaryen/test/wasm2js/br_table_to_loop.2asm.js + binaryen/test/wasm2js/br_table_to_loop.2asm.js.opt + binaryen/test/wasm2js/br_table_to_loop.wast + binaryen/test/wasm2js/break-drop.2asm.js + binaryen/test/wasm2js/bulk-memory.2asm.js + binaryen/test/wasm2js/bulk-memory.2asm.js.opt + binaryen/test/wasm2js/comments.2asm.js + binaryen/test/wasm2js/conversions-modified.2asm.js + binaryen/test/wasm2js/conversions-modified.2asm.js.opt + binaryen/test/wasm2js/conversions-modified.wast + binaryen/test/wasm2js/deterministic.2asm.js + binaryen/test/wasm2js/deterministic.2asm.js.opt + binaryen/test/wasm2js/deterministic.wast + binaryen/test/wasm2js/dot_import.2asm.js + binaryen/test/wasm2js/dot_import.2asm.js.opt + binaryen/test/wasm2js/dot_import.wast + binaryen/test/wasm2js/dynamicLibrary.2asm.js + binaryen/test/wasm2js/dynamicLibrary.2asm.js.opt + binaryen/test/wasm2js/dynamicLibrary.wast + binaryen/test/wasm2js/empty_export.2asm.js + binaryen/test/wasm2js/empty_export.2asm.js.opt + binaryen/test/wasm2js/empty_export.wast + binaryen/test/wasm2js/empty_imported_table.2asm.js + binaryen/test/wasm2js/empty_table.2asm.js + binaryen/test/wasm2js/emscripten-grow-no.2asm.js + binaryen/test/wasm2js/emscripten-grow-no.2asm.js.opt + binaryen/test/wasm2js/emscripten-grow-no.wast + binaryen/test/wasm2js/emscripten-grow-yes.2asm.js + binaryen/test/wasm2js/emscripten-grow-yes.2asm.js.opt + binaryen/test/wasm2js/emscripten-grow-yes.wast + binaryen/test/wasm2js/emscripten.2asm.js + binaryen/test/wasm2js/emscripten.2asm.js.opt + binaryen/test/wasm2js/emscripten.wast + binaryen/test/wasm2js/endianness.2asm.js + binaryen/test/wasm2js/excess_fallthrough.2asm.js + binaryen/test/wasm2js/excess_fallthrough.2asm.js.opt + binaryen/test/wasm2js/excess_fallthrough.wast + binaryen/test/wasm2js/f32.2asm.js + binaryen/test/wasm2js/f32_cmp.2asm.js + binaryen/test/wasm2js/f64_cmp.2asm.js + binaryen/test/wasm2js/fac.2asm.js + binaryen/test/wasm2js/float-ops.2asm.js + binaryen/test/wasm2js/float-ops.2asm.js.opt + binaryen/test/wasm2js/float-ops.wast + binaryen/test/wasm2js/float_literals-modified.2asm.js + binaryen/test/wasm2js/float_literals-modified.2asm.js.opt + binaryen/test/wasm2js/float_literals-modified.wast + binaryen/test/wasm2js/float_misc.2asm.js + binaryen/test/wasm2js/forward.2asm.js + binaryen/test/wasm2js/func-ptr-offset.2asm.js + binaryen/test/wasm2js/func-ptr-offset.2asm.js.opt + binaryen/test/wasm2js/func-ptr-offset.wast + binaryen/test/wasm2js/func_ptrs.2asm.js + binaryen/test/wasm2js/get-set-local.2asm.js + binaryen/test/wasm2js/get-set-local.2asm.js.opt + binaryen/test/wasm2js/get-set-local.wast + binaryen/test/wasm2js/get_local.2asm.js + binaryen/test/wasm2js/global_i64.2asm.js + binaryen/test/wasm2js/global_i64.2asm.js.opt + binaryen/test/wasm2js/global_i64.wast + binaryen/test/wasm2js/grow-memory-tricky.2asm.js + binaryen/test/wasm2js/grow-memory-tricky.2asm.js.opt + binaryen/test/wasm2js/grow-memory-tricky.wast + binaryen/test/wasm2js/grow_memory.2asm.js + binaryen/test/wasm2js/i32.2asm.js + binaryen/test/wasm2js/i64-add-sub.2asm.js + binaryen/test/wasm2js/i64-add-sub.2asm.js.opt + binaryen/test/wasm2js/i64-add-sub.wast + binaryen/test/wasm2js/i64-ctz.2asm.js + binaryen/test/wasm2js/i64-ctz.2asm.js.opt + binaryen/test/wasm2js/i64-ctz.wast + binaryen/test/wasm2js/i64-lowering.2asm.js + binaryen/test/wasm2js/i64-lowering.2asm.js.opt + binaryen/test/wasm2js/i64-lowering.wast + binaryen/test/wasm2js/i64-rotate.2asm.js + binaryen/test/wasm2js/i64-rotate.2asm.js.opt + binaryen/test/wasm2js/i64-rotate.wast + binaryen/test/wasm2js/i64-select.2asm.js + binaryen/test/wasm2js/i64-select.2asm.js.opt + binaryen/test/wasm2js/i64-select.wast + binaryen/test/wasm2js/i64-shifts.2asm.js + binaryen/test/wasm2js/i64-shifts.2asm.js.opt + binaryen/test/wasm2js/i64-shifts.wast + binaryen/test/wasm2js/if_unreachable.2asm.js + binaryen/test/wasm2js/if_unreachable.2asm.js.opt + binaryen/test/wasm2js/if_unreachable.wast + binaryen/test/wasm2js/indirect-select.2asm.js + binaryen/test/wasm2js/indirect-select.2asm.js.opt + binaryen/test/wasm2js/indirect-select.wast + binaryen/test/wasm2js/int_exprs.2asm.js + binaryen/test/wasm2js/labels.2asm.js + binaryen/test/wasm2js/left-to-right.2asm.js + binaryen/test/wasm2js/minified-memory.2asm.js + binaryen/test/wasm2js/minified-memory.2asm.js.opt + binaryen/test/wasm2js/minified-memory.wast + binaryen/test/wasm2js/minus_minus.2asm.js + binaryen/test/wasm2js/minus_minus.2asm.js.opt + binaryen/test/wasm2js/minus_minus.wast + binaryen/test/wasm2js/nested-selects.2asm.js + binaryen/test/wasm2js/nested-selects.2asm.js.opt + binaryen/test/wasm2js/nested-selects.wast + binaryen/test/wasm2js/ordering.2asm.js + binaryen/test/wasm2js/ordering.2asm.js.opt + binaryen/test/wasm2js/ordering.wast + binaryen/test/wasm2js/reinterpret.2asm.js + binaryen/test/wasm2js/reinterpret.2asm.js.opt + binaryen/test/wasm2js/reinterpret.wast + binaryen/test/wasm2js/reinterpret_scratch.2asm.js + binaryen/test/wasm2js/reinterpret_scratch.2asm.js.opt + binaryen/test/wasm2js/reinterpret_scratch.wast + binaryen/test/wasm2js/set_local.2asm.js + binaryen/test/wasm2js/sign_ext.2asm.js + binaryen/test/wasm2js/sign_ext.2asm.js.opt + binaryen/test/wasm2js/sign_ext.wast + binaryen/test/wasm2js/stack-modified.2asm.js + binaryen/test/wasm2js/stack-modified.2asm.js.opt + binaryen/test/wasm2js/stack-modified.wast + binaryen/test/wasm2js/start_func.2asm.js + binaryen/test/wasm2js/start_func.2asm.js.opt + binaryen/test/wasm2js/start_func.wast + binaryen/test/wasm2js/switch.2asm.js + binaryen/test/wasm2js/tee_local.2asm.js + binaryen/test/wasm2js/traps.2asm.js + binaryen/test/wasm2js/unaligned.2asm.js + binaryen/test/wasm2js/unaligned.2asm.js.opt + binaryen/test/wasm2js/unaligned.wast + binaryen/test/wasm2js/unary-ops.2asm.js + binaryen/test/wasm2js/unary-ops.2asm.js.opt + binaryen/test/wasm2js/unary-ops.wast + binaryen/test/wasm2js/unreachable-get-cycle.2asm.js + binaryen/test/wasm2js/unreachable-get-cycle.2asm.js.opt + binaryen/test/wasm2js/unreachable-get-cycle.wast + binaryen/test/wasm2js/unreachable-insts.2asm.js + binaryen/test/wasm2js/unreachable-insts.2asm.js.opt + binaryen/test/wasm2js/unreachable-insts.wast + binaryen/test/wasm2js/unreachable-later.2asm.js + binaryen/test/wasm2js/unreachable-later.2asm.js.opt + binaryen/test/wasm2js/unreachable-later.wast + binaryen/test/wasm2js/wasm2js.wast.asserts + binaryen/third_party/CMakeLists.txt + binaryen/third_party/llvm-project/Binary.cpp + binaryen/third_party/llvm-project/CMakeLists.txt + binaryen/third_party/llvm-project/ConvertUTF.cpp + binaryen/third_party/llvm-project/DataExtractor.cpp + binaryen/third_party/llvm-project/Debug.cpp + binaryen/third_party/llvm-project/DJB.cpp + binaryen/third_party/llvm-project/Dwarf.cpp + binaryen/third_party/llvm-project/dwarf2yaml.cpp + binaryen/third_party/llvm-project/DWARFAbbreviationDeclaration.cpp + binaryen/third_party/llvm-project/DWARFAcceleratorTable.cpp + binaryen/third_party/llvm-project/DWARFAddressRange.cpp + binaryen/third_party/llvm-project/DWARFCompileUnit.cpp + binaryen/third_party/llvm-project/DWARFContext.cpp + binaryen/third_party/llvm-project/DWARFDataExtractor.cpp + binaryen/third_party/llvm-project/DWARFDebugAbbrev.cpp + binaryen/third_party/llvm-project/DWARFDebugAddr.cpp + binaryen/third_party/llvm-project/DWARFDebugAranges.cpp + binaryen/third_party/llvm-project/DWARFDebugArangeSet.cpp + binaryen/third_party/llvm-project/DWARFDebugFrame.cpp + binaryen/third_party/llvm-project/DWARFDebugInfoEntry.cpp + binaryen/third_party/llvm-project/DWARFDebugLine.cpp + binaryen/third_party/llvm-project/DWARFDebugLoc.cpp + binaryen/third_party/llvm-project/DWARFDebugMacro.cpp + binaryen/third_party/llvm-project/DWARFDebugPubTable.cpp + binaryen/third_party/llvm-project/DWARFDebugRangeList.cpp + binaryen/third_party/llvm-project/DWARFDebugRnglists.cpp + binaryen/third_party/llvm-project/DWARFDie.cpp + binaryen/third_party/llvm-project/DWARFEmitter.cpp + binaryen/third_party/llvm-project/DWARFExpression.cpp + binaryen/third_party/llvm-project/DWARFFormValue.cpp + binaryen/third_party/llvm-project/DWARFGdbIndex.cpp + binaryen/third_party/llvm-project/DWARFListTable.cpp + binaryen/third_party/llvm-project/DWARFTypeUnit.cpp + binaryen/third_party/llvm-project/DWARFUnit.cpp + binaryen/third_party/llvm-project/DWARFUnitIndex.cpp + binaryen/third_party/llvm-project/DWARFVerifier.cpp + binaryen/third_party/llvm-project/DWARFVisitor.cpp + binaryen/third_party/llvm-project/DWARFVisitor.h + binaryen/third_party/llvm-project/DWARFYAML.cpp + binaryen/third_party/llvm-project/Error.cpp + binaryen/third_party/llvm-project/Error.h + binaryen/third_party/llvm-project/ErrorHandling.cpp + binaryen/third_party/llvm-project/FormatVariadic.cpp + binaryen/third_party/llvm-project/Hashing.cpp + binaryen/third_party/llvm-project/include/llvm-c/DataTypes.h + binaryen/third_party/llvm-project/include/llvm-c/DisassemblerTypes.h + binaryen/third_party/llvm-project/include/llvm-c/Error.h + binaryen/third_party/llvm-project/include/llvm-c/ErrorHandling.h + binaryen/third_party/llvm-project/include/llvm-c/Types.h + binaryen/third_party/llvm-project/include/llvm/ADT/AllocatorList.h + binaryen/third_party/llvm-project/include/llvm/ADT/APFloat.h + binaryen/third_party/llvm-project/include/llvm/ADT/APInt.h + binaryen/third_party/llvm-project/include/llvm/ADT/APSInt.h + binaryen/third_party/llvm-project/include/llvm/ADT/ArrayRef.h + binaryen/third_party/llvm-project/include/llvm/ADT/bit.h + binaryen/third_party/llvm-project/include/llvm/ADT/BitmaskEnum.h + binaryen/third_party/llvm-project/include/llvm/ADT/DenseMap.h + binaryen/third_party/llvm-project/include/llvm/ADT/DenseMapInfo.h + binaryen/third_party/llvm-project/include/llvm/ADT/DenseSet.h + binaryen/third_party/llvm-project/include/llvm/ADT/edit_distance.h + binaryen/third_party/llvm-project/include/llvm/ADT/EpochTracker.h + binaryen/third_party/llvm-project/include/llvm/ADT/fallible_iterator.h + binaryen/third_party/llvm-project/include/llvm/ADT/FoldingSet.h + binaryen/third_party/llvm-project/include/llvm/ADT/FunctionExtras.h + binaryen/third_party/llvm-project/include/llvm/ADT/Hashing.h + binaryen/third_party/llvm-project/include/llvm/ADT/ilist_base.h + binaryen/third_party/llvm-project/include/llvm/ADT/ilist_iterator.h + binaryen/third_party/llvm-project/include/llvm/ADT/ilist_node.h + binaryen/third_party/llvm-project/include/llvm/ADT/ilist_node_base.h + binaryen/third_party/llvm-project/include/llvm/ADT/ilist_node_options.h + binaryen/third_party/llvm-project/include/llvm/ADT/iterator.h + binaryen/third_party/llvm-project/include/llvm/ADT/iterator_range.h + binaryen/third_party/llvm-project/include/llvm/ADT/MapVector.h + binaryen/third_party/llvm-project/include/llvm/ADT/None.h + binaryen/third_party/llvm-project/include/llvm/ADT/Optional.h + binaryen/third_party/llvm-project/include/llvm/ADT/PointerIntPair.h + binaryen/third_party/llvm-project/include/llvm/ADT/PointerUnion.h + binaryen/third_party/llvm-project/include/llvm/ADT/simple_ilist.h + binaryen/third_party/llvm-project/include/llvm/ADT/SmallPtrSet.h + binaryen/third_party/llvm-project/include/llvm/ADT/SmallSet.h + binaryen/third_party/llvm-project/include/llvm/ADT/SmallString.h + binaryen/third_party/llvm-project/include/llvm/ADT/SmallVector.h + binaryen/third_party/llvm-project/include/llvm/ADT/STLExtras.h + binaryen/third_party/llvm-project/include/llvm/ADT/StringExtras.h + binaryen/third_party/llvm-project/include/llvm/ADT/StringMap.h + binaryen/third_party/llvm-project/include/llvm/ADT/StringRef.h + binaryen/third_party/llvm-project/include/llvm/ADT/StringSet.h + binaryen/third_party/llvm-project/include/llvm/ADT/StringSwitch.h + binaryen/third_party/llvm-project/include/llvm/ADT/Triple.h + binaryen/third_party/llvm-project/include/llvm/ADT/Twine.h + binaryen/third_party/llvm-project/include/llvm/BinaryFormat/COFF.h + binaryen/third_party/llvm-project/include/llvm/BinaryFormat/Dwarf.def + binaryen/third_party/llvm-project/include/llvm/BinaryFormat/Dwarf.h + binaryen/third_party/llvm-project/include/llvm/BinaryFormat/DynamicTags.def + binaryen/third_party/llvm-project/include/llvm/BinaryFormat/ELF.h + binaryen/third_party/llvm-project/include/llvm/BinaryFormat/ELFRelocs/AArch64.def + binaryen/third_party/llvm-project/include/llvm/BinaryFormat/ELFRelocs/AMDGPU.def + binaryen/third_party/llvm-project/include/llvm/BinaryFormat/ELFRelocs/ARC.def + binaryen/third_party/llvm-project/include/llvm/BinaryFormat/ELFRelocs/ARM.def + binaryen/third_party/llvm-project/include/llvm/BinaryFormat/ELFRelocs/AVR.def + binaryen/third_party/llvm-project/include/llvm/BinaryFormat/ELFRelocs/BPF.def + binaryen/third_party/llvm-project/include/llvm/BinaryFormat/ELFRelocs/Hexagon.def + binaryen/third_party/llvm-project/include/llvm/BinaryFormat/ELFRelocs/i386.def + binaryen/third_party/llvm-project/include/llvm/BinaryFormat/ELFRelocs/Lanai.def + binaryen/third_party/llvm-project/include/llvm/BinaryFormat/ELFRelocs/Mips.def + binaryen/third_party/llvm-project/include/llvm/BinaryFormat/ELFRelocs/MSP430.def + binaryen/third_party/llvm-project/include/llvm/BinaryFormat/ELFRelocs/PowerPC.def + binaryen/third_party/llvm-project/include/llvm/BinaryFormat/ELFRelocs/PowerPC64.def + binaryen/third_party/llvm-project/include/llvm/BinaryFormat/ELFRelocs/RISCV.def + binaryen/third_party/llvm-project/include/llvm/BinaryFormat/ELFRelocs/Sparc.def + binaryen/third_party/llvm-project/include/llvm/BinaryFormat/ELFRelocs/SystemZ.def + binaryen/third_party/llvm-project/include/llvm/BinaryFormat/ELFRelocs/x86_64.def + binaryen/third_party/llvm-project/include/llvm/BinaryFormat/MachO.def + binaryen/third_party/llvm-project/include/llvm/BinaryFormat/MachO.h + binaryen/third_party/llvm-project/include/llvm/BinaryFormat/Magic.h + binaryen/third_party/llvm-project/include/llvm/BinaryFormat/Wasm.h + binaryen/third_party/llvm-project/include/llvm/BinaryFormat/WasmRelocs.def + binaryen/third_party/llvm-project/include/llvm/Config/abi-breaking.h + binaryen/third_party/llvm-project/include/llvm/Config/config.h + binaryen/third_party/llvm-project/include/llvm/Config/llvm-config.h + binaryen/third_party/llvm-project/include/llvm/DebugInfo/DIContext.h + binaryen/third_party/llvm-project/include/llvm/DebugInfo/DWARF/DWARFAbbreviationDeclaration.h + binaryen/third_party/llvm-project/include/llvm/DebugInfo/DWARF/DWARFAcceleratorTable.h + binaryen/third_party/llvm-project/include/llvm/DebugInfo/DWARF/DWARFAddressRange.h + binaryen/third_party/llvm-project/include/llvm/DebugInfo/DWARF/DWARFAttribute.h + binaryen/third_party/llvm-project/include/llvm/DebugInfo/DWARF/DWARFCompileUnit.h + binaryen/third_party/llvm-project/include/llvm/DebugInfo/DWARF/DWARFContext.h + binaryen/third_party/llvm-project/include/llvm/DebugInfo/DWARF/DWARFDataExtractor.h + binaryen/third_party/llvm-project/include/llvm/DebugInfo/DWARF/DWARFDebugAbbrev.h + binaryen/third_party/llvm-project/include/llvm/DebugInfo/DWARF/DWARFDebugAddr.h + binaryen/third_party/llvm-project/include/llvm/DebugInfo/DWARF/DWARFDebugAranges.h + binaryen/third_party/llvm-project/include/llvm/DebugInfo/DWARF/DWARFDebugArangeSet.h + binaryen/third_party/llvm-project/include/llvm/DebugInfo/DWARF/DWARFDebugFrame.h + binaryen/third_party/llvm-project/include/llvm/DebugInfo/DWARF/DWARFDebugInfoEntry.h + binaryen/third_party/llvm-project/include/llvm/DebugInfo/DWARF/DWARFDebugLine.h + binaryen/third_party/llvm-project/include/llvm/DebugInfo/DWARF/DWARFDebugLoc.h + binaryen/third_party/llvm-project/include/llvm/DebugInfo/DWARF/DWARFDebugMacro.h + binaryen/third_party/llvm-project/include/llvm/DebugInfo/DWARF/DWARFDebugPubTable.h + binaryen/third_party/llvm-project/include/llvm/DebugInfo/DWARF/DWARFDebugRangeList.h + binaryen/third_party/llvm-project/include/llvm/DebugInfo/DWARF/DWARFDebugRnglists.h + binaryen/third_party/llvm-project/include/llvm/DebugInfo/DWARF/DWARFDie.h + binaryen/third_party/llvm-project/include/llvm/DebugInfo/DWARF/DWARFExpression.h + binaryen/third_party/llvm-project/include/llvm/DebugInfo/DWARF/DWARFFormValue.h + binaryen/third_party/llvm-project/include/llvm/DebugInfo/DWARF/DWARFGdbIndex.h + binaryen/third_party/llvm-project/include/llvm/DebugInfo/DWARF/DWARFListTable.h + binaryen/third_party/llvm-project/include/llvm/DebugInfo/DWARF/DWARFObject.h + binaryen/third_party/llvm-project/include/llvm/DebugInfo/DWARF/DWARFRelocMap.h + binaryen/third_party/llvm-project/include/llvm/DebugInfo/DWARF/DWARFSection.h + binaryen/third_party/llvm-project/include/llvm/DebugInfo/DWARF/DWARFTypeUnit.h + binaryen/third_party/llvm-project/include/llvm/DebugInfo/DWARF/DWARFUnit.h + binaryen/third_party/llvm-project/include/llvm/DebugInfo/DWARF/DWARFUnitIndex.h + binaryen/third_party/llvm-project/include/llvm/DebugInfo/DWARF/DWARFVerifier.h + binaryen/third_party/llvm-project/include/llvm/include/llvm/DebugInfo/DWARFContext.h + binaryen/third_party/llvm-project/include/llvm/LICENSE.TXT + binaryen/third_party/llvm-project/include/llvm/MC/LaneBitmask.h + binaryen/third_party/llvm-project/include/llvm/MC/MCExpr.h + binaryen/third_party/llvm-project/include/llvm/MC/MCFixup.h + binaryen/third_party/llvm-project/include/llvm/MC/MCFragment.h + binaryen/third_party/llvm-project/include/llvm/MC/MCInst.h + binaryen/third_party/llvm-project/include/llvm/MC/MCRegister.h + binaryen/third_party/llvm-project/include/llvm/MC/MCRegisterInfo.h + binaryen/third_party/llvm-project/include/llvm/MC/MCSymbol.h + binaryen/third_party/llvm-project/include/llvm/MC/MCSymbolWasm.h + binaryen/third_party/llvm-project/include/llvm/MC/SubtargetFeature.h + binaryen/third_party/llvm-project/include/llvm/Object/Archive.h + binaryen/third_party/llvm-project/include/llvm/Object/Binary.h + binaryen/third_party/llvm-project/include/llvm/Object/COFF.h + binaryen/third_party/llvm-project/include/llvm/Object/CVDebugRecord.h + binaryen/third_party/llvm-project/include/llvm/Object/Decompressor.h + binaryen/third_party/llvm-project/include/llvm/Object/ELF.h + binaryen/third_party/llvm-project/include/llvm/Object/ELFObjectFile.h + binaryen/third_party/llvm-project/include/llvm/Object/ELFTypes.h + binaryen/third_party/llvm-project/include/llvm/Object/Error.h + binaryen/third_party/llvm-project/include/llvm/Object/MachO.h + binaryen/third_party/llvm-project/include/llvm/Object/Minidump.h + binaryen/third_party/llvm-project/include/llvm/Object/ObjectFile.h + binaryen/third_party/llvm-project/include/llvm/Object/RelocationResolver.h + binaryen/third_party/llvm-project/include/llvm/Object/SymbolicFile.h + binaryen/third_party/llvm-project/include/llvm/Object/Wasm.h + binaryen/third_party/llvm-project/include/llvm/ObjectYAML/DWARFEmitter.h + binaryen/third_party/llvm-project/include/llvm/ObjectYAML/DWARFYAML.h + binaryen/third_party/llvm-project/include/llvm/ObjectYAML/ObjectYAML.h + binaryen/third_party/llvm-project/include/llvm/readme.txt + binaryen/third_party/llvm-project/include/llvm/Support/AArch64TargetParser.def + binaryen/third_party/llvm-project/include/llvm/Support/AArch64TargetParser.h + binaryen/third_party/llvm-project/include/llvm/Support/Alignment.h + binaryen/third_party/llvm-project/include/llvm/Support/AlignOf.h + binaryen/third_party/llvm-project/include/llvm/Support/Allocator.h + binaryen/third_party/llvm-project/include/llvm/Support/ARMAttributeParser.h + binaryen/third_party/llvm-project/include/llvm/Support/ARMBuildAttributes.h + binaryen/third_party/llvm-project/include/llvm/Support/ARMTargetParser.def + binaryen/third_party/llvm-project/include/llvm/Support/ARMTargetParser.h + binaryen/third_party/llvm-project/include/llvm/Support/BinaryByteStream.h + binaryen/third_party/llvm-project/include/llvm/Support/BinaryStream.h + binaryen/third_party/llvm-project/include/llvm/Support/BinaryStreamError.h + binaryen/third_party/llvm-project/include/llvm/Support/Casting.h + binaryen/third_party/llvm-project/include/llvm/Support/CBindingWrapping.h + binaryen/third_party/llvm-project/include/llvm/Support/Chrono.h + binaryen/third_party/llvm-project/include/llvm/Support/circular_raw_ostream.h + binaryen/third_party/llvm-project/include/llvm/Support/CodeGen.h + binaryen/third_party/llvm-project/include/llvm/Support/CommandLine.h + binaryen/third_party/llvm-project/include/llvm/Support/Compiler.h + binaryen/third_party/llvm-project/include/llvm/Support/ConvertUTF.h + binaryen/third_party/llvm-project/include/llvm/Support/DataExtractor.h + binaryen/third_party/llvm-project/include/llvm/Support/DataTypes.h + binaryen/third_party/llvm-project/include/llvm/Support/Debug.h + binaryen/third_party/llvm-project/include/llvm/Support/DJB.h + binaryen/third_party/llvm-project/include/llvm/Support/Endian.h + binaryen/third_party/llvm-project/include/llvm/Support/Errc.h + binaryen/third_party/llvm-project/include/llvm/Support/Errno.h + binaryen/third_party/llvm-project/include/llvm/Support/Error.h + binaryen/third_party/llvm-project/include/llvm/Support/ErrorHandling.h + binaryen/third_party/llvm-project/include/llvm/Support/ErrorOr.h + binaryen/third_party/llvm-project/include/llvm/Support/FileOutputBuffer.h + binaryen/third_party/llvm-project/include/llvm/Support/FileSystem.h + binaryen/third_party/llvm-project/include/llvm/Support/Format.h + binaryen/third_party/llvm-project/include/llvm/Support/FormatAdapters.h + binaryen/third_party/llvm-project/include/llvm/Support/FormatCommon.h + binaryen/third_party/llvm-project/include/llvm/Support/FormatProviders.h + binaryen/third_party/llvm-project/include/llvm/Support/FormattedStream.h + binaryen/third_party/llvm-project/include/llvm/Support/FormatVariadic.h + binaryen/third_party/llvm-project/include/llvm/Support/FormatVariadicDetails.h + binaryen/third_party/llvm-project/include/llvm/Support/Host.h + binaryen/third_party/llvm-project/include/llvm/Support/LEB128.h + binaryen/third_party/llvm-project/include/llvm/Support/LICENSE.TXT + binaryen/third_party/llvm-project/include/llvm/Support/LineIterator.h + binaryen/third_party/llvm-project/include/llvm/Support/Locale.h + binaryen/third_party/llvm-project/include/llvm/Support/ManagedStatic.h + binaryen/third_party/llvm-project/include/llvm/Support/MathExtras.h + binaryen/third_party/llvm-project/include/llvm/Support/MD5.h + binaryen/third_party/llvm-project/include/llvm/Support/MemAlloc.h + binaryen/third_party/llvm-project/include/llvm/Support/MemoryBuffer.h + binaryen/third_party/llvm-project/include/llvm/Support/NativeFormatting.h + binaryen/third_party/llvm-project/include/llvm/Support/Path.h + binaryen/third_party/llvm-project/include/llvm/Support/PointerLikeTypeTraits.h + binaryen/third_party/llvm-project/include/llvm/Support/Printable.h + binaryen/third_party/llvm-project/include/llvm/Support/Process.h + binaryen/third_party/llvm-project/include/llvm/Support/Program.h + binaryen/third_party/llvm-project/include/llvm/Support/raw_ostream.h + binaryen/third_party/llvm-project/include/llvm/Support/Regex.h + binaryen/third_party/llvm-project/include/llvm/Support/ReverseIteration.h + binaryen/third_party/llvm-project/include/llvm/Support/ScopedPrinter.h + binaryen/third_party/llvm-project/include/llvm/Support/Signals.h + binaryen/third_party/llvm-project/include/llvm/Support/SmallVectorMemoryBuffer.h + binaryen/third_party/llvm-project/include/llvm/Support/SMLoc.h + binaryen/third_party/llvm-project/include/llvm/Support/SourceMgr.h + binaryen/third_party/llvm-project/include/llvm/Support/SwapByteOrder.h + binaryen/third_party/llvm-project/include/llvm/Support/TargetParser.h + binaryen/third_party/llvm-project/include/llvm/Support/TargetRegistry.h + binaryen/third_party/llvm-project/include/llvm/Support/Threading.h + binaryen/third_party/llvm-project/include/llvm/Support/type_traits.h + binaryen/third_party/llvm-project/include/llvm/Support/TypeSize.h + binaryen/third_party/llvm-project/include/llvm/Support/Unicode.h + binaryen/third_party/llvm-project/include/llvm/Support/UnicodeCharRanges.h + binaryen/third_party/llvm-project/include/llvm/Support/WindowsError.h + binaryen/third_party/llvm-project/include/llvm/Support/WithColor.h + binaryen/third_party/llvm-project/include/llvm/Support/X86TargetParser.def + binaryen/third_party/llvm-project/include/llvm/Support/YAMLParser.h + binaryen/third_party/llvm-project/include/llvm/Support/YAMLTraits.h + binaryen/third_party/llvm-project/LEB128.cpp + binaryen/third_party/llvm-project/LineIterator.cpp + binaryen/third_party/llvm-project/MCRegisterInfo.cpp + binaryen/third_party/llvm-project/MD5.cpp + binaryen/third_party/llvm-project/MemoryBuffer.cpp + binaryen/third_party/llvm-project/NativeFormatting.cpp + binaryen/third_party/llvm-project/obj2yaml_Error.cpp + binaryen/third_party/llvm-project/ObjectFile.cpp + binaryen/third_party/llvm-project/Optional.cpp + binaryen/third_party/llvm-project/Path.cpp + binaryen/third_party/llvm-project/raw_ostream.cpp + binaryen/third_party/llvm-project/readme.txt + binaryen/third_party/llvm-project/ScopedPrinter.cpp + binaryen/third_party/llvm-project/SmallVector.cpp + binaryen/third_party/llvm-project/SourceMgr.cpp + binaryen/third_party/llvm-project/StringMap.cpp + binaryen/third_party/llvm-project/StringRef.cpp + binaryen/third_party/llvm-project/SymbolicFile.cpp + binaryen/third_party/llvm-project/Twine.cpp + binaryen/third_party/llvm-project/UnicodeCaseFold.cpp + binaryen/third_party/llvm-project/Unix/Path.inc + binaryen/third_party/llvm-project/Unix/Unix.h + binaryen/third_party/llvm-project/WithColor.cpp + binaryen/third_party/llvm-project/YAMLParser.cpp + binaryen/third_party/llvm-project/YAMLTraits.cpp + binaryen/third_party/setup.py + binaryen/third_party/wabt/wasm2c/README.md + binaryen/third_party/wabt/wasm2c/wasm-rt-impl.c + binaryen/third_party/wabt/wasm2c/wasm-rt-impl.h + binaryen/third_party/wabt/wasm2c/wasm-rt.h + binaryen/ubsan.blacklist + cbits/wrappers.c + CHANGELOG.md + LICENSE + README.md + +source-repository head + type: git + location: https://github.com/tweag/haskell-binaryen + +flag system-binaryen + description: Link against system-wide binaryen and don't build bundled binaryen + manual: True + default: False + +library + exposed-modules: + Binaryen + Binaryen.Event + Binaryen.Export + Binaryen.Expression + Binaryen.ExpressionId + Binaryen.ExternalKind + Binaryen.Features + Binaryen.Function + Binaryen.Global + Binaryen.Index + Binaryen.Module + Binaryen.Op + Binaryen.Relooper + Binaryen.SideEffects + Binaryen.Type + other-modules: + Paths_binaryen + autogen-modules: + Paths_binaryen + hs-source-dirs: + src + ghc-options: -Wall + build-depends: + base <5 + , libbinaryen + default-language: Haskell2010 + +library libbinaryen + other-modules: + Paths_binaryen + autogen-modules: + Paths_binaryen + ghc-options: -Wall + cc-options: -std=c11 -Wall -Wextra + c-sources: + cbits/wrappers.c + extra-libraries: + pthread + stdc++ + build-depends: + base <5 + if flag(system-binaryen) + extra-libraries: + binaryen + else + cxx-options: -D_GNU_SOURCE -D_DEBUG -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS -DBUILD_LLVM_DWARF -std=c++14 -Wall -Wextra -Wno-unused-parameter -Wno-implicit-int-float-conversion -Wno-unknown-warning-option -Wswitch + include-dirs: + binaryen/src + binaryen/third_party/llvm-project/include + cxx-sources: + binaryen/src/binaryen-c.cpp + binaryen/src/asmjs/asm_v_wasm.cpp + binaryen/src/asmjs/asmangle.cpp + binaryen/src/asmjs/shared-constants.cpp + binaryen/src/cfg/Relooper.cpp + binaryen/src/emscripten-optimizer/optimizer-shared.cpp + binaryen/src/emscripten-optimizer/parser.cpp + binaryen/src/emscripten-optimizer/simple_ast.cpp + binaryen/src/ir/ExpressionAnalyzer.cpp + binaryen/src/ir/ExpressionManipulator.cpp + binaryen/src/ir/LocalGraph.cpp + binaryen/src/ir/ReFinalize.cpp + binaryen/src/ir/stack-utils.cpp + binaryen/src/passes/AlignmentLowering.cpp + binaryen/src/passes/Asyncify.cpp + binaryen/src/passes/AvoidReinterprets.cpp + binaryen/src/passes/CoalesceLocals.cpp + binaryen/src/passes/CodeFolding.cpp + binaryen/src/passes/CodePushing.cpp + binaryen/src/passes/ConstHoisting.cpp + binaryen/src/passes/DataFlowOpts.cpp + binaryen/src/passes/DeadArgumentElimination.cpp + binaryen/src/passes/DeadCodeElimination.cpp + binaryen/src/passes/DeAlign.cpp + binaryen/src/passes/DeNaN.cpp + binaryen/src/passes/Directize.cpp + binaryen/src/passes/DuplicateFunctionElimination.cpp + binaryen/src/passes/DuplicateImportElimination.cpp + binaryen/src/passes/DWARF.cpp + binaryen/src/passes/EmscriptenPIC.cpp + binaryen/src/passes/ExtractFunction.cpp + binaryen/src/passes/Flatten.cpp + binaryen/src/passes/FuncCastEmulation.cpp + binaryen/src/passes/GenerateDynCalls.cpp + binaryen/src/passes/I64ToI32Lowering.cpp + binaryen/src/passes/Inlining.cpp + binaryen/src/passes/InstrumentLocals.cpp + binaryen/src/passes/InstrumentMemory.cpp + binaryen/src/passes/LegalizeJSInterface.cpp + binaryen/src/passes/LimitSegments.cpp + binaryen/src/passes/LocalCSE.cpp + binaryen/src/passes/LogExecution.cpp + binaryen/src/passes/LoopInvariantCodeMotion.cpp + binaryen/src/passes/MemoryPacking.cpp + binaryen/src/passes/MergeBlocks.cpp + binaryen/src/passes/MergeLocals.cpp + binaryen/src/passes/Metrics.cpp + binaryen/src/passes/MinifyImportsAndExports.cpp + binaryen/src/passes/NameList.cpp + binaryen/src/passes/NoExitRuntime.cpp + binaryen/src/passes/OptimizeAddedConstants.cpp + binaryen/src/passes/OptimizeInstructions.cpp + binaryen/src/passes/pass.cpp + binaryen/src/passes/PickLoadSigns.cpp + binaryen/src/passes/PostAssemblyScript.cpp + binaryen/src/passes/PostEmscripten.cpp + binaryen/src/passes/Precompute.cpp + binaryen/src/passes/Print.cpp + binaryen/src/passes/PrintCallGraph.cpp + binaryen/src/passes/PrintFeatures.cpp + binaryen/src/passes/PrintFunctionMap.cpp + binaryen/src/passes/RedundantSetElimination.cpp + binaryen/src/passes/RemoveImports.cpp + binaryen/src/passes/RemoveMemory.cpp + binaryen/src/passes/RemoveNonJSOps.cpp + binaryen/src/passes/RemoveUnusedBrs.cpp + binaryen/src/passes/RemoveUnusedModuleElements.cpp + binaryen/src/passes/RemoveUnusedNames.cpp + binaryen/src/passes/ReorderFunctions.cpp + binaryen/src/passes/ReorderLocals.cpp + binaryen/src/passes/ReplaceStackPointer.cpp + binaryen/src/passes/ReReloop.cpp + binaryen/src/passes/RoundTrip.cpp + binaryen/src/passes/SafeHeap.cpp + binaryen/src/passes/SimplifyGlobals.cpp + binaryen/src/passes/SimplifyLocals.cpp + binaryen/src/passes/Souperify.cpp + binaryen/src/passes/SpillPointers.cpp + binaryen/src/passes/SSAify.cpp + binaryen/src/passes/StackCheck.cpp + binaryen/src/passes/StackIR.cpp + binaryen/src/passes/Strip.cpp + binaryen/src/passes/StripTargetFeatures.cpp + binaryen/src/passes/TrapMode.cpp + binaryen/src/passes/Untee.cpp + binaryen/src/passes/Vacuum.cpp + binaryen/src/passes/WasmIntrinsics.cpp + binaryen/src/support/archive.cpp + binaryen/src/support/bits.cpp + binaryen/src/support/colors.cpp + binaryen/src/support/command-line.cpp + binaryen/src/support/debug.cpp + binaryen/src/support/file.cpp + binaryen/src/support/path.cpp + binaryen/src/support/safe_integer.cpp + binaryen/src/support/threads.cpp + binaryen/src/support/utilities.cpp + binaryen/src/wasm/literal.cpp + binaryen/src/wasm/wasm-binary.cpp + binaryen/src/wasm/wasm-debug.cpp + binaryen/src/wasm/wasm-emscripten.cpp + binaryen/src/wasm/wasm-interpreter.cpp + binaryen/src/wasm/wasm-io.cpp + binaryen/src/wasm/wasm-s-parser.cpp + binaryen/src/wasm/wasm-stack.cpp + binaryen/src/wasm/wasm-type.cpp + binaryen/src/wasm/wasm-validator.cpp + binaryen/src/wasm/wasm.cpp + binaryen/third_party/llvm-project/Binary.cpp + binaryen/third_party/llvm-project/ConvertUTF.cpp + binaryen/third_party/llvm-project/DataExtractor.cpp + binaryen/third_party/llvm-project/Debug.cpp + binaryen/third_party/llvm-project/DJB.cpp + binaryen/third_party/llvm-project/Dwarf.cpp + binaryen/third_party/llvm-project/dwarf2yaml.cpp + binaryen/third_party/llvm-project/DWARFAbbreviationDeclaration.cpp + binaryen/third_party/llvm-project/DWARFAcceleratorTable.cpp + binaryen/third_party/llvm-project/DWARFAddressRange.cpp + binaryen/third_party/llvm-project/DWARFCompileUnit.cpp + binaryen/third_party/llvm-project/DWARFContext.cpp + binaryen/third_party/llvm-project/DWARFDataExtractor.cpp + binaryen/third_party/llvm-project/DWARFDebugAbbrev.cpp + binaryen/third_party/llvm-project/DWARFDebugAddr.cpp + binaryen/third_party/llvm-project/DWARFDebugAranges.cpp + binaryen/third_party/llvm-project/DWARFDebugArangeSet.cpp + binaryen/third_party/llvm-project/DWARFDebugFrame.cpp + binaryen/third_party/llvm-project/DWARFDebugInfoEntry.cpp + binaryen/third_party/llvm-project/DWARFDebugLine.cpp + binaryen/third_party/llvm-project/DWARFDebugLoc.cpp + binaryen/third_party/llvm-project/DWARFDebugMacro.cpp + binaryen/third_party/llvm-project/DWARFDebugPubTable.cpp + binaryen/third_party/llvm-project/DWARFDebugRangeList.cpp + binaryen/third_party/llvm-project/DWARFDebugRnglists.cpp + binaryen/third_party/llvm-project/DWARFDie.cpp + binaryen/third_party/llvm-project/DWARFEmitter.cpp + binaryen/third_party/llvm-project/DWARFExpression.cpp + binaryen/third_party/llvm-project/DWARFFormValue.cpp + binaryen/third_party/llvm-project/DWARFGdbIndex.cpp + binaryen/third_party/llvm-project/DWARFListTable.cpp + binaryen/third_party/llvm-project/DWARFTypeUnit.cpp + binaryen/third_party/llvm-project/DWARFUnit.cpp + binaryen/third_party/llvm-project/DWARFUnitIndex.cpp + binaryen/third_party/llvm-project/DWARFVerifier.cpp + binaryen/third_party/llvm-project/DWARFVisitor.cpp + binaryen/third_party/llvm-project/DWARFYAML.cpp + binaryen/third_party/llvm-project/Error.cpp + binaryen/third_party/llvm-project/ErrorHandling.cpp + binaryen/third_party/llvm-project/FormatVariadic.cpp + binaryen/third_party/llvm-project/Hashing.cpp + binaryen/third_party/llvm-project/LEB128.cpp + binaryen/third_party/llvm-project/LineIterator.cpp + binaryen/third_party/llvm-project/MCRegisterInfo.cpp + binaryen/third_party/llvm-project/MD5.cpp + binaryen/third_party/llvm-project/MemoryBuffer.cpp + binaryen/third_party/llvm-project/NativeFormatting.cpp + binaryen/third_party/llvm-project/obj2yaml_Error.cpp + binaryen/third_party/llvm-project/ObjectFile.cpp + binaryen/third_party/llvm-project/Optional.cpp + binaryen/third_party/llvm-project/Path.cpp + binaryen/third_party/llvm-project/raw_ostream.cpp + binaryen/third_party/llvm-project/ScopedPrinter.cpp + binaryen/third_party/llvm-project/SmallVector.cpp + binaryen/third_party/llvm-project/SourceMgr.cpp + binaryen/third_party/llvm-project/StringMap.cpp + binaryen/third_party/llvm-project/StringRef.cpp + binaryen/third_party/llvm-project/SymbolicFile.cpp + binaryen/third_party/llvm-project/Twine.cpp + binaryen/third_party/llvm-project/UnicodeCaseFold.cpp + binaryen/third_party/llvm-project/WithColor.cpp + binaryen/third_party/llvm-project/YAMLParser.cpp + binaryen/third_party/llvm-project/YAMLTraits.cpp + default-language: Haskell2010 + +test-suite test + type: exitcode-stdio-1.0 + main-is: test.hs + other-modules: + Paths_binaryen + autogen-modules: + Paths_binaryen + hs-source-dirs: + test + ghc-options: -Wall -threaded -rtsopts + build-depends: + base <5 + , binaryen default-language: Haskell2010 diff --git a/binaryen/CHANGELOG.md b/binaryen/CHANGELOG.md new file mode 100644 --- /dev/null +++ b/binaryen/CHANGELOG.md @@ -0,0 +1,241 @@ +Changelog +========= + +This document describes changes between tagged Binaryen versions. + +To browse or download snapshots of old tagged versions, visit +https://github.com/WebAssembly/binaryen/releases. + +Not all changes are documented here. In particular, new features, user-oriented +fixes, options, command-line parameters, usage changes, deprecations, +significant internal modifications and optimizations etc. generally deserve a +mention. To examine the full set of changes between versions, visit the link to +full changeset diff at the end of each section. + +Current Trunk +------------- + +v98 +--- + +- Add `--fast-math` mode. (#3155) +- Initial implementation of "Memory64" proposal (#3130) +- Lots of changes in support of GC proposal + +v97 +--- + +- Remove asm2wasm, which supported Emscripten's fastcomp backend, after fastcomp + was removed. +- The new feature flag `--enable-anyref` enables just the `anyref` type incl. + basic subtyping of `externref`, `funcref` and `exnref` (if enabled). +- Enabling the exception handling or anyref features without also enabling + reference types is a validation error now. +- The `Host` expression and its respective APIs have been refactored into + separate `MemorySize` and `MemoryGrow` expressions to align with other memory + instructions. + +v96 +--- + +- Fuzzing: Compare wasm2js to the interpreter (#3026) +- Fix CountLeadingZeroes on MSVC, which lead to bad optimizations (#3028) +- Asyncify verbose option (#3022) +- wasm2js: Add an "Export" scope for name resolution, avoids annoying + warnings (#2998) +- Extend the C- and JS-APIs (#2586) + +v95 +--- + +- Add Asyncify "add list" that adds to the list of functions to be instrumented. + Rename old lists to be clearer and more consistent with that, so now there is + "remove list" to remove, "add list" to add, and "only list" which if set means + that only those functions should be instrumented and nothing else. +- Renamed various ambiguous C-API functions for consistency: + - `BinaryenBlockGetChild` to `BinaryenBlockGetChildAt` + - `BinaryenSwitchGetName` to `BinaryenSwitchGetNameAt` + - `BinaryenCallGetOperand` to `BinaryenCallGetOperandAt` + - `BinaryenCallIndirectGetOperand` to `BinaryenCallIndirectGetOperandAt` + - `BinaryenHostGetOperand` to `BinaryenHostGetOperandAt` + - `BinaryenThrowGetOperand` to `BinaryenThrowGetOperandAt` + - `BinaryenTupleMakeGetOperand` to `BinaryenTupleMakeGetOperandAt` + +v94 +--- + +- The C-API's `BinaryenSetAPITracing` and the JS-API's `setAPITracing` have been + removed because this feature was not very useful anymore and had a significant + maintainance cost. +- wasm-emscripten-finalize will no longer generate `stackSave`, `stackAlloc`, + `stackRestore` function. It not expects them to be included in the input + file. + +v93 +--- + +- First release with binaries built with github actions. + + +v92 +--- + +- The `multivalue` feature has been added. It allows functions and control flow + structures to return tuples and for locals and globals to have tuple types. + Tuples are created with the new `tuple.make` pseudoinstruction and their + elements are retrieved with the new `tuple.extract` pseudoinstruction. +- The internal type interner has been rewritten to avoid taking locks in far + more situations. Depending on the workload, this may result in large speedups + and increased parallelism. +- Represent the `dylink` section in Binaryen IR, so we can read, write, and + update it. + +v91 +--- + +- `BinaryenExpressionGetSideEffects` (C API) and `getSideEffects` (JS API) now + takes an additional `features` parameter. +- Reference type support is added. Supported instructions are `ref.null`, + `ref.is_null`, `ref.func`, and typed `select`. Table instructions are not + supported yet. For typed `select`, C/JS API can take an additional 'type' + parameter. + +v90 +--- + +- `local.tee`'s C/Binaryen.js API now takes an additional type parameter for its + local type, like `local.get`. This is required to handle subtypes. +- Added load_splat SIMD instructions +- Binaryen.js instruction API changes: + - `notify` -> `atomic.notify` + - `i32.wait` / `i64.wait` -> `i32.atomic.wait` / `i64.atomic.wait` +- Binaryen.js: `flags` argument in `setMemory` function is removed. +- `atomic.fence` instruction support is added. +- wasm-emscripten-finalize: Don't rely on name section being present in the + input. Use the exported names for things instead. +- Added `mutable` parameter to BinaryenAddGlobalImport. +- Replace BinaryenSIMDBitselect* with BinaryenSIMDTernary* in the C API and add + qfma/qfms instructions. +- Added `offset` parameter to BinaryenSetFunctionTable. +- Add the ability to create multivalue Types in the C and JS APIs. +- Remove named function types. They are replaced by `params` and `results` types + local to each function. +- Binaryen.js can now be compiled to Wasm using the `binaryen_wasm` target. + Unlike the JS variant, the Wasm variant requires asynchronously awaiting the + Wasm blob's instantiation and initialization before being usable, using the + `binaryen.ready` promise, e.g. `binaryen.ready.then(() => ...)`. +- Binaryen.js now uses `binaryen` (was `Binaryen`) as its global name to align + with the npm package. +- Binaryen.js: The result of `getMemorySegmentInfoByIndex` now has the same + structure as the respective inputs on creation (`byteOffset` -> `offset`). + +v88 +--- + +- wasm-emscripten-finalize: For -pie binaries that import a mutable stack + pointer we internalize this an import it as immutable. +- The `tail-call` feature including the `return_call` and `return_call_indirect` + instructions is ready to use. + +v87 +--- + +- Rename Bysyncify => Asyncify + +v86 +--- + +- The --initial-stack-pointer argument to wasm-emscripten-finalize no longer + has any effect. It will be removed completely in future release. + +v85 +--- + +- Wast file parsing rules now don't allow a few invalid formats for typeuses + that were previously allowed. Typeuse entries should follow this format, + meaning they should have (type) -> (param) -> (result) order if more than one + of them exist. + ``` + typeuse ::= (type index|name)+ | + (type index|name)+ (param ..)* (result ..)* | + (param ..)* (result ..)* + ``` + Also, all (local) nodes in function definition should be after all typeuse + elements. +- Removed APIs related to deprecated instruction names in Binaryen.js: + - `get_local` / `getLocal` + - `set_local` / `setLocal` + - `tee_local` / `teeLocal` + - `get_global` / `getGlobal` + - `set_global` / `setGlobal` + - `current_memory` / `currentMemory` + - `grow_memory` / `growMemory` + They are now available as their new instruction names: + `local.get`, `local.set`, `local.tee`, `global.get`, `global.set`, + `memory.size`, and `memory.grow`. +- Add feature handling to the C/JS API with no feature enabled by default. + +v84 +--- + +- Generate dynCall thunks for any signatures used in "invoke" calls. + +v81 +--- + +- Fix AsmConstWalker handling of string address in arg0 with -fPIC code + +v80 +--- + +- Change default feature set in the absence of a target features section from + all features to MVP. + +v79 +--- + +- Improve support for side modules + +v78 +--- + +- Add `namedGlobals` to metadata output of wasm-emscripten-finalize +- Add support for llvm PIC code. +- Add --side-module option to wasm-emscripten-finalize. +- Add `segmentPassive` argument to `BinaryenSetMemory` for marking segments + passive. +- Make `-o -` print to stdout instead of a file named "-". + +v73 +--- + +- Remove wasm-merge tool. + +v73 +--- + +- Remove jsCall generation from wasm-emscripten-finalize. This is not needed + as of https://github.com/emscripten-core/emscripten/pull/8255. + +v55 +--- + +- `RelooperCreate` in the C API now has a Module parameter, and + `RelooperRenderAndDispose` does not. + - The JS API now has the `Relooper` constructor receive the `Module`. +- Relooper: Condition properties on Branches must not have side effects. + +older +----- + +- `BinaryenSetFunctionTable` in the C API no longer accepts an array of + functions, instead it accepts an array of function names, `const char** + funcNames`. Previously, you could not include imported functions because they + are of type `BinaryenImportRef` instead of `BinaryenFunctionRef`. #1650 + +- `BinaryenSetFunctionTable` in the C API now expects the initial and maximum + table size as additional parameters, like `BinaryenSetMemory` does for pages, + so tables can be grown dynamically. #1687 + +- Add `shared` parameters to `BinaryenAddMemoryImport` and `BinaryenSetMemory`, + to support a shared memory. #1686 diff --git a/binaryen/CMakeLists.txt b/binaryen/CMakeLists.txt new file mode 100644 --- /dev/null +++ b/binaryen/CMakeLists.txt @@ -0,0 +1,390 @@ +cmake_minimum_required(VERSION 3.1.3) +project(binaryen LANGUAGES C CXX VERSION 98) +include(GNUInstallDirs) + +# The C++ standard whose features are required to build Binaryen. +# Keep in sync with scripts/test/shared.py cxx_standard +set(CXX_STANDARD 14) + +if(NOT CMAKE_BUILD_TYPE) + message(STATUS "No build type selected, default to Release") + set(CMAKE_BUILD_TYPE "Release") +endif() + +# We default to assertions enabled, even in release builds so that we get +# more useful error reports from users. +option(BYN_ENABLE_ASSERTIONS "Enable assertions" ON) + +# For git users, attempt to generate a more useful version string +if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/.git) + find_package(Git QUIET REQUIRED) + execute_process(COMMAND + "${GIT_EXECUTABLE}" --git-dir=${CMAKE_CURRENT_SOURCE_DIR}/.git describe --tags --match version_* + RESULT_VARIABLE + GIT_VERSION_RESULT + OUTPUT_VARIABLE + GIT_VERSION + OUTPUT_STRIP_TRAILING_WHITESPACE) + if(${GIT_VERSION_RESULT}) + message(WARNING "Error running git describe to determine version") + else() + set(PROJECT_VERSION "${PROJECT_VERSION} (${GIT_VERSION})") + endif() +endif() + +configure_file(config.h.in config.h) + +# Support functionality. + +function(ADD_COMPILE_FLAG value) + message(STATUS "Building with ${value}") + FOREACH(variable CMAKE_C_FLAGS CMAKE_CXX_FLAGS) + set(${variable} "${${variable}} ${value}" PARENT_SCOPE) + ENDFOREACH(variable) +endfunction() + +function(ADD_CXX_FLAG value) + message(STATUS "Building with ${value}") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${value}" PARENT_SCOPE) +endfunction() + +function(ADD_DEBUG_COMPILE_FLAG value) + if("${CMAKE_BUILD_TYPE}" MATCHES "Debug") + message(STATUS "Building with ${value}") + endif() + FOREACH(variable CMAKE_C_FLAGS_DEBUG CMAKE_CXX_FLAGS_DEBUG) + set(${variable} "${${variable}} ${value}" PARENT_SCOPE) + ENDFOREACH(variable) +endfunction() + +function(ADD_NONDEBUG_COMPILE_FLAG value) + if(NOT "${CMAKE_BUILD_TYPE}" MATCHES "Debug") + message(STATUS "Building with ${value}") + endif() + FOREACH(variable CMAKE_C_FLAGS_RELEASE CMAKE_CXX_FLAGS_RELEASE CMAKE_C_FLAGS_RELWITHDEBINFO CMAKE_CXX_FLAGS_RELWITHDEBINFO CMAKE_C_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_MINSIZEREL) + set(${variable} "${${variable}} ${value}" PARENT_SCOPE) + ENDFOREACH(variable) +endfunction() + +function(ADD_LINK_FLAG value) + message(STATUS "Linking with ${value}") + FOREACH(variable CMAKE_EXE_LINKER_FLAGS) + set(${variable} "${${variable}} ${value}" PARENT_SCOPE) + ENDFOREACH(variable) +endfunction() + +function(binaryen_setup_rpath name) + if(CMAKE_INSTALL_RPATH) + return() + endif() + + if (APPLE) + set(_install_name_dir INSTALL_NAME_DIR "@rpath") + set(_install_rpath "@loader_path/../lib") + elseif(UNIX) + set(_install_rpath "\$ORIGIN/../lib") + if(${CMAKE_SYSTEM_NAME} MATCHES "(FreeBSD|DragonFly)") + set_property(TARGET ${name} APPEND_STRING PROPERTY + LINK_FLAGS " -Wl,-z,origin ") + endif() + else() + return() + endif() + + set_target_properties(${name} PROPERTIES + BUILD_WITH_INSTALL_RPATH On + INSTALL_RPATH "${_install_rpath}" + ${_install_name_dir}) +endfunction() + +# Options + +option(BUILD_STATIC_LIB "Build as a static library" OFF) +if (MSVC) + # We don't have dllexport declarations set up for windows yet. + set(BUILD_STATIC_LIB ON) +endif() + +# For now, don't include full DWARF support in JS builds, for size. +if (NOT EMSCRIPTEN) + option(BUILD_LLVM_DWARF "Enable full DWARF support" ON) + + if(BUILD_LLVM_DWARF) + if(MSVC) + ADD_COMPILE_FLAG("/DBUILD_LLVM_DWARF") + else() + ADD_COMPILE_FLAG("-DBUILD_LLVM_DWARF") + endif() + endif() +endif() + +# Compiler setup. + +include_directories(${CMAKE_CURRENT_SOURCE_DIR}/src) +if(BUILD_LLVM_DWARF) + include_directories(${CMAKE_CURRENT_SOURCE_DIR}/third_party/llvm-project/include) +endif() + +# Add output directory to include path so config.h can be found +include_directories(${CMAKE_CURRENT_BINARY_DIR}) + +# Force output to bin/ and lib/. This is to suppress CMake multigenerator output paths and avoid bin/Debug, bin/Release/ and so on, which is CMake default. +FOREACH(SUFFIX "_DEBUG" "_RELEASE" "_RELWITHDEBINFO" "_MINSIZEREL" "") + set(CMAKE_RUNTIME_OUTPUT_DIRECTORY${SUFFIX} "${PROJECT_BINARY_DIR}/bin") + set(CMAKE_LIBRARY_OUTPUT_DIRECTORY${SUFFIX} "${PROJECT_BINARY_DIR}/lib") + set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY${SUFFIX} "${PROJECT_BINARY_DIR}/lib") +ENDFOREACH() + +if(MSVC) + if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "19.0") # VS2013 and older explicitly need /arch:sse2 set, VS2015 no longer has that option, but always enabled. + add_compile_flag("/arch:sse2") + endif() + add_compile_flag("/wd4146") # Ignore warning "warning C4146: unary minus operator applied to unsigned type, result still unsigned", this pattern is used somewhat commonly in the code. + # 4267 and 4244 are conversion/truncation warnings. We might want to fix these but they are currently pervasive. + add_compile_flag("/wd4267") + add_compile_flag("/wd4244") + # 4722 warns that destructors never return, even with WASM_NORETURN. + add_compile_flag("/wd4722") + # "destructor was implicitly defined as deleted" caused by LLVM headers. + add_compile_flag("/wd4624") + add_compile_flag("/WX-") + add_debug_compile_flag("/Od") + add_nondebug_compile_flag("/O2") + add_compile_flag("/D_CRT_SECURE_NO_WARNINGS") + add_compile_flag("/D_SCL_SECURE_NO_WARNINGS") + # Visual Studio 2018 15.8 implemented conformant support for std::aligned_storage, but the conformant support is only enabled when the following flag is passed, to avoid + # breaking backwards compatibility with code that relied on the non-conformant behavior (the old nonconformant behavior is not used with Binaryen) + add_compile_flag("/D_ENABLE_EXTENDED_ALIGNED_STORAGE") + # Don't warn about using "strdup" as a reserved name. + add_compile_flag("/D_CRT_NONSTDC_NO_DEPRECATE") + + # multi-core build. + add_compile_flag("/MP") + + if(BYN_ENABLE_ASSERTIONS) + # On non-Debug builds cmake automatically defines NDEBUG, so we + # explicitly undefine it: + add_nondebug_compile_flag("/UNDEBUG") # Keep asserts. + endif() + # Also remove /D NDEBUG to avoid MSVC warnings about conflicting defines. + if( NOT CMAKE_BUILD_TYPE MATCHES "Debug" ) + foreach(flags_var_to_scrub + CMAKE_CXX_FLAGS_RELEASE + CMAKE_CXX_FLAGS_RELWITHDEBINFO + CMAKE_CXX_FLAGS_MINSIZEREL + CMAKE_C_FLAGS_RELEASE + CMAKE_C_FLAGS_RELWITHDEBINFO + CMAKE_C_FLAGS_MINSIZEREL) + string(REGEX REPLACE "(^| )[/-]D *NDEBUG($| )" " " + "${flags_var_to_scrub}" "${${flags_var_to_scrub}}") + + # Compile with `/MT` to link against `libcmt.lib`, removing a dependency + # on `msvcrt.dll`. May result in slightly larger binaries but they should + # be more portable across systems. + string(REPLACE "/MD" "/MT" ${flags_var_to_scrub} "${${flags_var_to_scrub}}") + endforeach() + endif() + + add_link_flag("/STACK:8388608") + + if(RUN_STATIC_ANALYZER) + add_definitions(/analyze) + endif() +else() + + option(ENABLE_WERROR "Enable -Werror" ON) + + set(THREADS_PREFER_PTHREAD_FLAG ON) + set(CMAKE_THREAD_PREFER_PTHREAD ON) + find_package(Threads REQUIRED) + add_cxx_flag("-std=c++${CXX_STANDARD}") + if(NOT EMSCRIPTEN) + if(CMAKE_SYSTEM_PROCESSOR MATCHES "^i.86$") + # wasm doesn't allow for x87 floating point math + add_compile_flag("-msse2") + add_compile_flag("-mfpmath=sse") + elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^armv[2-6]" AND NOT CMAKE_CXX_FLAGS MATCHES "-mfpu=") + add_compile_flag("-mfpu=vfpv3") + endif() + endif() + add_compile_flag("-Wall") + if(ENABLE_WERROR) + add_compile_flag("-Werror") + endif() + add_compile_flag("-Wextra") + add_compile_flag("-Wno-unused-parameter") + add_compile_flag("-fno-omit-frame-pointer") + # TODO(https://github.com/WebAssembly/binaryen/pull/2314): Remove these two + # flags once we resolve the issue. + add_compile_flag("-Wno-implicit-int-float-conversion") + add_compile_flag("-Wno-unknown-warning-option") + add_compile_flag("-Wswitch") # we explicitly expect this in the code + if(WIN32) + add_compile_flag("-D_GNU_SOURCE") + add_link_flag("-Wl,--stack,8388608") + elseif(NOT EMSCRIPTEN) + add_compile_flag("-fPIC") + endif() + add_debug_compile_flag("-O0") + add_debug_compile_flag("-g3") + if(EMSCRIPTEN) + # really focus on minimizing output size when compiling sources + add_nondebug_compile_flag("-Oz") + else() + add_nondebug_compile_flag("-O2") + endif() + if(BYN_ENABLE_ASSERTIONS) + # On non-Debug builds cmake automatically defines NDEBUG, so we + # explicitly undefine it: + add_nondebug_compile_flag("-UNDEBUG") + endif() +endif() + +if(EMSCRIPTEN) + # link with -O3 for metadce and other powerful optimizations. note that we + # must use add_link_options so that this appears after CMake's default -O2 + add_link_options("-O3") + add_link_flag("-s SINGLE_FILE") + add_link_flag("-s ALLOW_MEMORY_GROWTH=1") + add_compile_flag("-s DISABLE_EXCEPTION_CATCHING=0") + add_link_flag("-s DISABLE_EXCEPTION_CATCHING=0") + # make the tools immediately usable on Node.js + add_link_flag("-s NODERAWFS") + # in opt builds, LTO helps so much (>20%) it's worth slow compile times + add_nondebug_compile_flag("-flto") +endif() + +# clang doesn't print colored diagnostics when invoked from Ninja +if(UNIX AND CMAKE_GENERATOR STREQUAL "Ninja") + if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU") + add_compile_flag("-fdiagnostics-color=always") + elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Clang") + add_compile_flag("-fcolor-diagnostics") + endif() +endif() + +# Static libraries +# Current (partial) dependency structure is as follows: +# passes -> wasm -> asmjs -> support +# TODO: It's odd that wasm should depend on asmjs, maybe we should fix that. +add_subdirectory(src/ir) +add_subdirectory(src/asmjs) +add_subdirectory(src/cfg) +add_subdirectory(src/emscripten-optimizer) +add_subdirectory(src/passes) +add_subdirectory(src/support) +add_subdirectory(src/wasm) +add_subdirectory(third_party) + +# Object files +set(binaryen_objs + $ + $ + $ + $ + $ + $ + $) + +IF(BUILD_LLVM_DWARF) + SET(binaryen_objs ${binaryen_objs} $) +ENDIF() + +# Sources. + +file(GLOB binaryen_HEADERS src/*.h) +set(binaryen_SOURCES + src/binaryen-c.cpp + ${binaryen_HEADERS} +) +if(BUILD_STATIC_LIB) + message(STATUS "Building libbinaryen as statically linked library.") + add_library(binaryen STATIC ${binaryen_SOURCES} ${binaryen_objs}) + add_definitions(-DBUILD_STATIC_LIBRARY) +else() + message(STATUS "Building libbinaryen as shared library.") + add_library(binaryen SHARED ${binaryen_SOURCES} ${binaryen_objs}) +endif() +install(TARGETS binaryen + RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} + LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} + ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}) + +install(FILES src/binaryen-c.h DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}) + +function(binaryen_add_executable name sources) + add_executable(${name} ${sources}) + target_link_libraries(${name} ${CMAKE_THREAD_LIBS_INIT}) + target_link_libraries(${name} binaryen) + set_property(TARGET ${name} PROPERTY CXX_STANDARD ${CXX_STANDARD}) + set_property(TARGET ${name} PROPERTY CXX_STANDARD_REQUIRED ON) + binaryen_setup_rpath(${name}) + install(TARGETS ${name} DESTINATION ${CMAKE_INSTALL_BINDIR}) +endfunction() + +binaryen_add_executable(wasm-opt src/tools/wasm-opt.cpp) +binaryen_add_executable(wasm-shell src/tools/wasm-shell.cpp) +binaryen_add_executable(wasm-metadce src/tools/wasm-metadce.cpp) +binaryen_add_executable(wasm2js src/tools/wasm2js.cpp) +binaryen_add_executable(wasm-emscripten-finalize src/tools/wasm-emscripten-finalize.cpp) +binaryen_add_executable(wasm-as src/tools/wasm-as.cpp) +binaryen_add_executable(wasm-dis src/tools/wasm-dis.cpp) +binaryen_add_executable(wasm-ctor-eval src/tools/wasm-ctor-eval.cpp) +binaryen_add_executable(wasm-reduce src/tools/wasm-reduce.cpp) + + +# binaryen.js +# +# Note that we can't emit binaryen.js directly, as there is libbinaryen already +# declared earlier, so we create binaryen_wasm/js.js, which must then be copied. +# Note that SHELL: is needed as otherwise cmake will coalesce -s link flags +# in an incorrect way for emscripten. +if(EMSCRIPTEN) + set(binaryen_emscripten_SOURCES + src/binaryen-c.cpp + ${binaryen_HEADERS} + ) + + # binaryen.js WebAssembly variant + add_executable(binaryen_wasm + ${binaryen_emscripten_SOURCES}) + target_link_libraries(binaryen_wasm wasm asmjs emscripten-optimizer passes ir cfg support wasm) + target_link_libraries(binaryen_wasm "-s NO_FILESYSTEM=0") + target_link_libraries(binaryen_wasm "-s NODERAWFS=0") + target_link_libraries(binaryen_wasm "-s EXPORT_NAME=binaryen") + target_link_libraries(binaryen_wasm "--post-js ${CMAKE_CURRENT_SOURCE_DIR}/src/js/binaryen.js-post.js") + target_link_libraries(binaryen_wasm "--extern-pre-js ${CMAKE_CURRENT_SOURCE_DIR}/src/js/binaryen.js-extern-pre.js") + target_link_libraries(binaryen_wasm "--extern-post-js ${CMAKE_CURRENT_SOURCE_DIR}/src/js/binaryen.js-extern-post.js") + target_link_libraries(binaryen_wasm optimized "--closure 1") + target_link_libraries(binaryen_wasm optimized "--closure-args \"--language_in=ECMASCRIPT6 --language_out=ECMASCRIPT6\"") + target_link_libraries(binaryen_wasm optimized "-flto") + target_link_libraries(binaryen_wasm debug "--profiling") + set_property(TARGET binaryen_wasm PROPERTY CXX_STANDARD ${CXX_STANDARD}) + set_property(TARGET binaryen_wasm PROPERTY CXX_STANDARD_REQUIRED ON) + install(TARGETS binaryen_wasm DESTINATION ${CMAKE_INSTALL_BINDIR}) + + # binaryen.js JavaScript variant + add_executable(binaryen_js + ${binaryen_emscripten_SOURCES}) + target_link_libraries(binaryen_js wasm asmjs emscripten-optimizer passes ir cfg support wasm) + target_link_libraries(binaryen_js "-s WASM=0") + target_link_libraries(binaryen_js "-s WASM_ASYNC_COMPILATION=0") + if(${CMAKE_CXX_COMPILER_VERSION} STREQUAL "6.0.1") + # only valid with fastcomp and WASM=0 + target_link_libraries(binaryen_js "-s ELIMINATE_DUPLICATE_FUNCTIONS=1") + endif() + target_link_libraries(binaryen_js "-s NO_FILESYSTEM=0") + target_link_libraries(binaryen_js "-s NODERAWFS=0") + target_link_libraries(binaryen_js "-s EXPORT_NAME=binaryen") + target_link_libraries(binaryen_js "--post-js ${CMAKE_CURRENT_SOURCE_DIR}/src/js/binaryen.js-post.js") + target_link_libraries(binaryen_js "--extern-pre-js ${CMAKE_CURRENT_SOURCE_DIR}/src/js/binaryen.js-extern-pre.js") + target_link_libraries(binaryen_js "--extern-post-js ${CMAKE_CURRENT_SOURCE_DIR}/src/js/binaryen.js-extern-post.js") + target_link_libraries(binaryen_js optimized "--closure 1") + target_link_libraries(binaryen_js optimized "--closure-args \"--language_in=ECMASCRIPT6 --language_out=ECMASCRIPT6\"") + target_link_libraries(binaryen_js optimized "-flto") + target_link_libraries(binaryen_js debug "--profiling") + target_link_libraries(binaryen_js debug "-s ASSERTIONS") + set_property(TARGET binaryen_js PROPERTY CXX_STANDARD ${CXX_STANDARD}) + set_property(TARGET binaryen_js PROPERTY CXX_STANDARD_REQUIRED ON) + install(TARGETS binaryen_js DESTINATION ${CMAKE_INSTALL_BINDIR}) +endif() diff --git a/binaryen/Contributing.md b/binaryen/Contributing.md new file mode 100644 --- /dev/null +++ b/binaryen/Contributing.md @@ -0,0 +1,33 @@ +# Contributing to WebAssembly + +Interested in participating? Please follow +[the same contributing guidelines as the design repository][]. + + [the same contributing guidelines as the design repository]: https://github.com/WebAssembly/design/blob/master/Contributing.md + +Also, please be sure to read [the README.md](README.md) for this repository. + +## Adding support for new instructions + +Use this handy checklist to make sure your new instructions are fully supported: + + - [ ] Instruction class or opcode added to src/wasm.h + - [ ] Instruction class added to src/wasm-builder.h + - [ ] Instruction class added to src/wasm-traversal.h + - [ ] Validation added to src/wasm/wasm-validator.cpp + - [ ] Interpretation added to src/wasm-interpreter.h + - [ ] Effects handled in src/ir/effects.h + - [ ] Precomputing handled in src/passes/Precompute.cpp + - [ ] Hashing and comparing in src/ir/ExpressionAnalyzer.cpp + - [ ] Parsing added in scripts/gen-s-parser.py, src/wasm-s-parser.h and src/wasm/wasm-s-parser.cpp + - [ ] Printing added in src/passes/Print.cpp + - [ ] Decoding added in src/wasm-binary.h and src/wasm/wasm-binary.cpp + - [ ] Binary writing added in src/wasm-stack.h and src/wasm/wasm-stack.cpp + - [ ] Support added in various classes inheriting OverriddenVisitor (and possibly other non-OverriddenVisitor classes as necessary) + - [ ] Support added to src/tools/fuzzing.h + - [ ] C API support added in src/binaryen-c.h and src/binaryen-c.cpp + - [ ] JS API support added in src/js/binaryen.js-post.js + - [ ] C API tested in test/example/c-api-kitchen-sink.c + - [ ] JS API tested in test/binaryen.js/kitchen-sink.js + - [ ] Tests added in test/spec + - [ ] Tests added in top-level test/ diff --git a/binaryen/LICENSE b/binaryen/LICENSE new file mode 100644 --- /dev/null +++ b/binaryen/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "{}" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright {yyyy} {name of copyright owner} + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/binaryen/README.md b/binaryen/README.md new file mode 100644 --- /dev/null +++ b/binaryen/README.md @@ -0,0 +1,495 @@ +[![CI](https://github.com/WebAssembly/binaryen/workflows/CI/badge.svg?branch=master&event=push)](https://github.com/WebAssembly/binaryen/actions?query=workflow%3ACI) + +# Binaryen + +Binaryen is a compiler and toolchain infrastructure library for WebAssembly, +written in C++. It aims to make [compiling to WebAssembly] **easy, fast, and +effective**: + + * **Easy**: Binaryen has a simple [C API] in a single header, and can also be + [used from JavaScript][JS_API]. It accepts input in [WebAssembly-like + form][compile_to_wasm] but also accepts a general [control flow graph] for + compilers that prefer that. + + * **Fast**: Binaryen's internal IR uses compact data structures and is designed + for completely parallel codegen and optimization, using all available CPU + cores. Binaryen's IR also compiles down to WebAssembly extremely easily and + quickly because it is essentially a subset of WebAssembly. + + * **Effective**: Binaryen's optimizer has many passes (see an overview later + down) that can improve code size and speed. These optimizations aim to make + Binaryen powerful enough to be used as a [compiler backend][backend] by + itself. One specific area of focus is on WebAssembly-specific optimizations + (that general-purpose compilers might not do), which you can think of as + wasm [minification], similar to minification for JavaScript, CSS, etc., all + of which are language-specific. + +Compilers using Binaryen include: + + * [`AssemblyScript`](https://github.com/AssemblyScript/assemblyscript) which compiles a subset of TypeScript to WebAssembly + * [`wasm2js`](https://github.com/WebAssembly/binaryen/blob/master/src/wasm2js.h) which compiles WebAssembly to JS + * [`Asterius`](https://github.com/tweag/asterius) which compiles Haskell to WebAssembly + * [`Grain`](https://github.com/grain-lang/grain) which compiles Grain to WebAssembly + +Binaryen also provides a set of **toolchain utilities** that can + + * **Parse** and **emit** WebAssembly. In particular this lets you load + WebAssembly, optimize it using Binaryen, and re-emit it, thus implementing a + wasm-to-wasm optimizer in a single command. + * **Interpret** WebAssembly as well as run the WebAssembly spec tests. + * Integrate with **[Emscripten](http://emscripten.org)** in order to provide a + complete compiler toolchain from C and C++ to WebAssembly. + * **Polyfill** WebAssembly by running it in the interpreter compiled to + JavaScript, if the browser does not yet have native support (useful for + testing). + +Consult the [contributing instructions](Contributing.md) if you're interested in +participating. + +## Binaryen IR + +Binaryen's internal IR is designed to be + + * **Flexible and fast** for optimization. + * **As close as possible to WebAssembly** so it is simple and fast to convert + it to and from WebAssembly. + +There are a few differences between Binaryen IR and the WebAssembly language: + + * Tree structure + * Binaryen IR [is a tree][binaryen_ir], i.e., it has hierarchical structure, + for convenience of optimization. This differs from the WebAssembly binary + format which is a stack machine. + * Consequently Binaryen's text format allows only s-expressions. + WebAssembly's official text format is primarily a linear instruction list + (with s-expression extensions). Binaryen can't read the linear style, but + it can read a wasm text file if it contains only s-expressions. + * Binaryen uses Stack IR to optimize "stacky" code (that can't be + represented in structured form). + * When stacky code must be represented in Binaryen IR, such as with + multivalue instructions and blocks, it is represented with tuple types that + do not exist in the WebAssembly language. In addition to multivalue + instructions, locals and globals can also have tuple types in Binaryen IR + but not in WebAssembly. + * Types and unreachable code + * WebAssembly limits block/if/loop types to none and the concrete value types + (i32, i64, f32, f64). Binaryen IR has an unreachable type, and it allows + block/if/loop to take it, allowing [local transforms that don't need to + know the global context][unreachable]. As a result, Binaryen's default + text output is not necessarily valid wasm text. (To get valid wasm text, + you can do `--generate-stack-ir --print-stack-ir`, which prints Stack IR, + this is guaranteed to be valid for wasm parsers.) + * Binaryen ignores unreachable code when reading WebAssembly binaries. That + means that if you read a wasm file with unreachable code, that code will be + discarded as if it were optimized out (often this is what you want anyhow, + and optimized programs have no unreachable code anyway, but if you write an + unoptimized file and then read it, it may look different). The reason for + this behavior is that unreachable code in WebAssembly has corner cases that + are tricky to handle in Binaryen IR (it can be very unstructured, and + Binaryen IR is more structured than WebAssembly as noted earlier). Note + that Binaryen does support unreachable code in .wat text files, since as we + saw Binaryen only supports s-expressions there, which are structured. + * Blocks + * Binaryen IR has only one node that contains a variable-length list of + operands: the block. WebAssembly on the other hand allows lists in loops, + if arms, and the top level of a function. Binaryen's IR has a single + operand for all non-block nodes; this operand may of course be a block. + The motivation for this property is that many passes need special code + for iterating on lists, so having a single IR node with a list simplifies + them. + * As in wasm, blocks and loops may have names. Branch targets in the IR are + resolved by name (as opposed to nesting depth). This has 2 consequences: + * Blocks without names may not be branch targets. + * Names are required to be unique. (Reading .wat files with duplicate names + is supported; the names are modified when the IR is constructed). + * As an optimization, a block that is the child of a loop (or if arm, or + function toplevel) and which has no branches targeting it will not be + emitted when generating wasm. Instead its list of operands will be directly + used in the containing node. Such a block is sometimes called an "implicit + block". + * Multivalue + * Binaryen will not represent multivalue instructions and values directly. + Binaryen's main focus is on optimization of wasm, and therefore the question + of whether we should have multivalue in the main IR is whether it justifes + the extra complexity there. Experiments show that the shrinking of code + size thanks to multivalue is useful but small, just 1-3% or so. Given that, + we prefer to keep the main IR simple, and focus on multivalue optimizations + in Stack IR, which is more suitable for such things. + * Binaryen does still need to implement the "ABI" level of multivalue, that + is, we need multivalue calls because those may cross module boundaries, + and so they are observable externally. To support that, Binaryen may use + `push` and `pop` as mentioned earlier; another option is to add LLVM-like + `extractvalue/composevalue` instructions. + +As a result, you might notice that round-trip conversions (wasm => Binaryen IR +=> wasm) change code a little in some corner cases. + + * When optimizing Binaryen uses an additional IR, Stack IR (see + `src/wasm-stack.h`). Stack IR allows a bunch of optimizations that are + tailored for the stack machine form of WebAssembly's binary format (but Stack + IR is less efficient for general optimizations than the main Binaryen IR). If + you have a wasm file that has been particularly well-optimized, a simple + round-trip conversion (just read and write, without optimization) may cause + more noticeable differences, as Binaryen fits it into Binaryen IR's more + structured format. If you also optimize during the round-trip conversion then + Stack IR opts will be run and the final wasm will be better optimized. + +Notes when working with Binaryen IR: + + * As mentioned above, Binaryen IR has a tree structure. As a result, each + expression should have exactly one parent - you should not "reuse" a node by + having it appear more than once in the tree. The motivation for this + limitation is that when we optimize we modify nodes, so if they appear more + than once in the tree, a change in one place can appear in another + incorrectly. + * For similar reasons, nodes should not appear in more than one functions. + +## Tools + +This repository contains code that builds the following tools in `bin/`: + + * **wasm-opt**: Loads WebAssembly and runs Binaryen IR passes on it. + * **wasm-as**: Assembles WebAssembly in text format (currently S-Expression + format) into binary format (going through Binaryen IR). + * **wasm-dis**: Un-assembles WebAssembly in binary format into text format + (going through Binaryen IR). + * **wasm2js**: A WebAssembly-to-JS compiler. This is used by Emscripten to + generate JavaScript as an alternative to WebAssembly. + * **wasm-reduce**: A testcase reducer for WebAssembly files. Given a wasm file + that is interesting for some reason (say, it crashes a specific VM), + wasm-reduce can find a smaller wasm file that has the same property, which is + often easier to debug. See the + [docs](https://github.com/WebAssembly/binaryen/wiki/Fuzzing#reducing) + for more details. + * **wasm-shell**: A shell that can load and interpret WebAssembly code. It can + also run the spec test suite. + * **wasm-emscripten-finalize**: Takes a wasm binary produced by llvm+lld and + performs emscripten-specific passes over it. + * **wasm-ctor-eval**: A tool that can execute C++ global constructors ahead of + time. Used by Emscripten. + * **binaryen.js**: A standalone JavaScript library that exposes Binaryen methods for [creating and optimizing WASM modules](https://github.com/WebAssembly/binaryen/blob/master/test/binaryen.js/hello-world.js). For builds, see [binaryen.js on npm](https://www.npmjs.com/package/binaryen) (or download it directly from [github](https://raw.githubusercontent.com/AssemblyScript/binaryen.js/master/index.js), [rawgit](https://cdn.rawgit.com/AssemblyScript/binaryen.js/master/index.js), or [unpkg](https://unpkg.com/binaryen@latest/index.js)). + +Usage instructions for each are below. + +## Binaryen Optimizations + +Binaryen contains +[a lot of optimization passes](https://github.com/WebAssembly/binaryen/tree/master/src/passes) +to make WebAssembly smaller and faster. You can run the Binaryen optimizer by +using ``wasm-opt``, but also they can be run while using other tools, like +``wasm2js`` and ``wasm-metadce``. + +* The default optimization pipeline is set up by functions like + [`addDefaultFunctionOptimizationPasses`](https://github.com/WebAssembly/binaryen/blob/369b8bdd3d9d49e4d9e0edf62e14881c14d9e352/src/passes/pass.cpp#L396). +* There are various + [pass options](https://github.com/WebAssembly/binaryen/blob/369b8bdd3d9d49e4d9e0edf62e14881c14d9e352/src/pass.h#L85) + that you can set, to adjust the optimization and shrink levels, whether to + ignore unlikely traps, inlining heuristics, fast-math, and so forth. See + ``wasm-opt --help`` for how to set them and other details. + +See each optimization pass for details of what it does, but here is a quick +overview of some of the relevant ones: + +* **CoalesceLocals** - Key “register allocation” pass. Does a live range + analysis and then reuses locals in order to minimize their number, as well as + to remove copies between them. +* **CodeFolding** - Avoids duplicate code by merging it (e.g. if two `if` arms + have some shared instructions at their end). +* **CodePushing** - “Pushes” code forward past branch operations, potentially + allowing the code to not be run if the branch is taken. +* **DeadArgumentElimination** - LTO pass to remove arguments to a function if it + is always called with the same constants. +* **DeadCodeElimination** +* **Directize** - Turn an indirect call into a normal call, when the table index + is constant. +* **DuplicateFunctionElimination** - LTO pass. +* **Inlining** - LTO pass. +* **LocalCSE** - Simple local common subexpression elimination. +* **LoopInvariantCodeMotion** +* **MemoryPacking** - Key "optimize data segments" pass that combines segments, + removes unneeded parts, etc. +* **MergeBlocks** - Merge a `block` to an outer one where possible, reducing + their number. +* **MergeLocals** - When two locals have the same value in part of their + overlap, pick in a way to help CoalesceLocals do better later (split off from + CoalesceLocals to keep the latter simple). +* **MinifyImportsAndExports** - Minifies them to “a”, “b”, etc. +* **OptimizeAddedConstants** - Optimize a load/store with an added constant into + a constant offset. +* **OptimizeInstructions** - Key peephole optimization pass with a constantly + increasing list of patterns. +* **PickLoadSigns** - Adjust whether a load is signed or unsigned in order to + avoid sign/unsign operations later. +* **Precompute** - Calculates constant expressions at compile time, using the + built-in interpreter (which is guaranteed to be able to handle any constant + expression). +* **ReReloop** - Transforms wasm structured control flow to a CFG and then goes + back to structured form using the Relooper algorithm, which may find more + optimal shapes. +* **RedundantSetElimination** - Removes a `local.set` of a value that is already + present in a local. (Overlaps with CoalesceLocals; this achieves the specific + operation just mentioned without all the other work CoalesceLocals does, and + therefore is useful in other places in the optimization pipeline.) +* **RemoveUnsedBrs** - Key “minor control flow optimizations” pass, including + jump threading and various transforms that can get rid of a `br` or `br_table` + (like turning a `block` with a `br` in the middle into an `if` when possible). +* **RemoveUnusedModuleElements** - “Global DCE”, an LTO pass that removes + imports, functions, globals, etc., when they are not used. +* **ReorderFunctions** - Put more-called functions first, potentially allowing + the LEB emitted to call them to be smaller (in a very large program). +* **ReorderLocals** - Put more-used locals first, potentially allowing the LEB + emitted to use them to be smaller (in a very large function). After the + sorting, it also removes locals not used at all. +* **SimplifyGlobals** - Optimizes globals in various ways, for example, + coalescing them, removing mutability from a global never modified, applying a + constant value from an immutable global, etc. +* **SimplifyLocals** - Key “`local.get/set/tee`” optimization pass, doing things + like replacing a set and a get with moving the set’s value to the get (and + creating a tee) where possible. Also creates `block/if/loop` return values + instead of using a local to pass the value. +* **Vacuum** - Key “remove silly unneeded code” pass, doing things like removing + an `if` arm that has no contents, a drop of a constant value with no side + effects, a `block` with a single child, etc. + +“LTO” in the above means an optimization is Link Time Optimization-like in that +it works across multiple functions, but in a sense Binaryen is always “LTO” as +it usually is run on the final linked wasm. + +Advanced optimization techniques in the Binaryen optimizer include +[SSAification](https://github.com/WebAssembly/binaryen/blob/master/src/passes/SSAify.cpp), +[Flat IR](https://github.com/WebAssembly/binaryen/blob/master/src/ir/flat.h), and +[Stack/Poppy IR](https://github.com/WebAssembly/binaryen/blob/master/src/ir/stack-utils.h). + +Binaryen also contains various passes that do other things than optimizations, +like +[legalization for JavaScript](https://github.com/WebAssembly/binaryen/blob/master/src/passes/LegalizeJSInterface.cpp), +[Asyncify](https://github.com/WebAssembly/binaryen/blob/master/src/passes/Asyncify.cpp), +etc. + +## Building + +``` +cmake . && make +``` + +A C++14 compiler is required. Note that you can also use `ninja` as your generator: `cmake -G Ninja . && ninja`. + +Binaryen.js can be built using Emscripten, which can be installed via [the SDK](http://kripken.github.io/emscripten-site/docs/getting_started/downloads.html)). + +``` +emcmake cmake . && emmake make binaryen_js +``` + +### Visual C++ + +1. Using the Microsoft Visual Studio Installer, install the "Visual C++ tools for CMake" component. + +1. Generate the projects: + + ``` + mkdir build + cd build + "%VISUAL_STUDIO_ROOT%\Common7\IDE\CommonExtensions\Microsoft\CMake\CMake\bin\cmake.exe" .. + ``` + + Substitute VISUAL_STUDIO_ROOT with the path to your Visual Studio + installation. In case you are using the Visual Studio Build Tools, the path + will be "C:\Program Files (x86)\Microsoft Visual Studio\2017\BuildTools". + +1. From the Developer Command Prompt, build the desired projects: + + ``` + msbuild binaryen.vcxproj + ``` + + CMake generates a project named "ALL_BUILD.vcxproj" for conveniently building all the projects. + +## Running + +### wasm-opt + +Run + +```` +bin/wasm-opt [.wasm or .wat file] [options] [passes, see --help] [--help] +```` + +The wasm optimizer receives WebAssembly as input, and can run transformation +passes on it, as well as print it (before and/or after the transformations). For +example, try + +```` +bin/wasm-opt test/passes/lower-if-else.wat --print +```` + +That will pretty-print out one of the test cases in the test suite. To run a +transformation pass on it, try + +```` +bin/wasm-opt test/passes/lower-if-else.wat --print --lower-if-else +```` + +The `lower-if-else` pass lowers if-else into a block and a break. You can see +the change the transformation causes by comparing the output of the two print +commands. + +It's easy to add your own transformation passes to the shell, just add `.cpp` +files into `src/passes`, and rebuild the shell. For example code, take a look at +the [`lower-if-else` pass](https://github.com/WebAssembly/binaryen/blob/master/src/passes/LowerIfElse.cpp). + +Some more notes: + + * See `bin/wasm-opt --help` for the full list of options and passes. + * Passing `--debug` will emit some debugging info. + +### wasm2js + +Run + +``` +bin/wasm2js [input.wasm file] +``` + +This will print out JavaScript to the console. + +For example, try + +``` +$ bin/wasm2js test/hello_world.wat +``` + +That output contains + +``` + function add(x, y) { + x = x | 0; + y = y | 0; + return x + y | 0 | 0; + } +``` + +as a translation of + +``` + (func $add (; 0 ;) (type $0) (param $x i32) (param $y i32) (result i32) + (i32.add + (local.get $x) + (local.get $y) + ) + ) +``` + +wasm2js's output is in ES6 module format - basically, it converts a wasm +module into an ES6 module (to run on older browsers and Node.js versions +you can use Babel etc. to convert it to ES5). Let's look at a full example +of calling that hello world wat; first, create the main JS file: + +```javascript +// main.mjs +import { add } from "./hello_world.mjs"; +console.log('the sum of 1 and 2 is:', add(1, 2)); +``` + +The run this (note that you need a new enough Node.js with ES6 module +support): + +```shell +$ bin/wasm2js test/hello_world.wat -o hello_world.mjs +$ node --experimental-modules main.mjs +the sum of 1 and 2 is: 3 +``` + +Things keep to in mind with wasm2js's output: + + * You should run wasm2js with optimizations for release builds, using `-O` + or another optimization level. That will optimize along the entire pipeline + (wasm and JS). It won't do everything a JS minifer would, though, like + minify whitespace, so you should still run a normal JS minifer afterwards. + * It is not possible to match WebAssembly semantics 100% precisely with fast + JavaScript code. For example, every load and store may trap, and to make + JavaScript do the same we'd need to add checks everywhere, which would be + large and slow. Instead, wasm2js assumes loads and stores do not trap, that + int/float conversions do not trap, and so forth. There may also be slight + differences in corner cases of conversions, like non-trapping float to int. + +## Testing + +``` +./check.py +``` + +(or `python check.py`) will run `wasm-shell`, `wasm-opt`, etc. on the testcases in `test/`, and verify their outputs. + +The `check.py` script supports some options: + +``` +./check.py [--interpreter=/path/to/interpreter] [TEST1] [TEST2].. +``` + + * If an interpreter is provided, we run the output through it, checking for + parse errors. + * If tests are provided, we run exactly those. If none are provided, we run + them all. To see what tests are available, run `./check.py --list-suites`. + * Some tests require `emcc` or `nodejs` in the path. They will not run if the + tool cannot be found, and you'll see a warning. + * We have tests from upstream in `tests/spec`, in git submodules. Running + `./check.py` should update those. + +### Setting up dependencies + +``` +./third_party/setup.py [mozjs|v8|wabt|all] +``` + +(or `python third_party/setup.py`) installs required dependencies like the SpiderMonkey JS shell, the V8 JS shell +and WABT in `third_party/`. Other scripts automatically pick these up when installed. + +### Fuzzing + +``` +./scripts/fuzz_opt.py [--binaryen-bin=build/bin] +``` + +(or `python scripts/fuzz_opt.py`) will run various fuzzing modes on random inputs with random passes until it finds +a possible bug. See [the wiki page](https://github.com/WebAssembly/binaryen/wiki/Fuzzing) for all the details. + +## Design Principles + + * **Interned strings for names**: It's very convenient to have names on nodes, + instead of just numeric indices etc. To avoid most of the performance + difference between strings and numeric indices, all strings are interned, + which means there is a single copy of each string in memory, string + comparisons are just a pointer comparison, etc. + * **Allocate in arenas**: Based on experience with other + optimizing/transformating toolchains, it's not worth the overhead to + carefully track memory of individual nodes. Instead, we allocate all elements + of a module in an arena, and the entire arena can be freed when the module is + no longer needed. + +## FAQ + +* Why the weird name for the project? + +"Binaryen" is a combination of **binary** - since WebAssembly is a binary format +for the web - and **Emscripten** - with which it can integrate in order to +compile C and C++ all the way to WebAssembly, via asm.js. Binaryen began as +Emscripten's WebAssembly processing library (`wasm-emscripten`). + +"Binaryen" is pronounced [in the same manner](http://www.makinggameofthrones.com/production-diary/2011/2/11/official-pronunciation-guide-for-game-of-thrones.html) as "[Targaryen](https://en.wikipedia.org/wiki/List_of_A_Song_of_Ice_and_Fire_characters#House_Targaryen)": *bi-NAIR-ee-in*. Or something like that? Anyhow, however Targaryen is correctly pronounced, they should rhyme. Aside from pronunciation, the Targaryen house words, "Fire and Blood", have also inspired Binaryen's: "Code and Bugs." + +* Does it compile under Windows and/or Visual Studio? + +Yes, it does. Here's a step-by-step [tutorial][win32] on how to compile it +under **Windows 10 x64** with with **CMake** and **Visual Studio 2015**. Help +would be appreciated on Windows and OS X as most of the core devs are on Linux. + +[compiling to WebAssembly]: https://github.com/WebAssembly/binaryen/wiki/Compiling-to-WebAssembly-with-Binaryen +[win32]: https://github.com/brakmic/bazaar/blob/master/webassembly/COMPILING_WIN32.md +[C API]: https://github.com/WebAssembly/binaryen/wiki/Compiling-to-WebAssembly-with-Binaryen#c-api-1 +[control flow graph]: https://github.com/WebAssembly/binaryen/wiki/Compiling-to-WebAssembly-with-Binaryen#cfg-api +[JS_API]: https://github.com/WebAssembly/binaryen/wiki/binaryen.js-API +[compile_to_wasm]: https://github.com/WebAssembly/binaryen/wiki/Compiling-to-WebAssembly-with-Binaryen#what-do-i-need-to-have-in-order-to-use-binaryen-to-compile-to-webassembly +[backend]: https://kripken.github.io/talks/binaryen.html#/9 +[minification]: https://kripken.github.io/talks/binaryen.html#/2 +[unreachable]: https://github.com/WebAssembly/binaryen/issues/903 +[binaryen_ir]: https://github.com/WebAssembly/binaryen/issues/663 diff --git a/binaryen/auto_update_tests.py b/binaryen/auto_update_tests.py new file mode 100644 --- /dev/null +++ b/binaryen/auto_update_tests.py @@ -0,0 +1,187 @@ +#!/usr/bin/env python3 +# +# Copyright 2015 WebAssembly Community Group participants +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import os +import subprocess +import sys +from collections import OrderedDict + +from scripts.test import binaryenjs +from scripts.test import lld +from scripts.test import shared +from scripts.test import support +from scripts.test import wasm2js +from scripts.test import wasm_opt + + +def update_example_tests(): + print('\n[ checking example testcases... ]\n') + for t in shared.get_tests(shared.get_test_dir('example')): + basename = os.path.basename(t) + output_file = os.path.join(shared.options.binaryen_bin, 'example') + libdir = os.path.join(shared.BINARYEN_INSTALL_DIR, 'lib') + cmd = ['-I' + os.path.join(shared.options.binaryen_root, 'src'), '-g', '-pthread', '-o', output_file] + if t.endswith('.txt'): + # check if there is a trace in the file, if so, we should build it + out = subprocess.Popen([os.path.join(shared.options.binaryen_root, 'scripts', 'clean_c_api_trace.py'), t], stdout=subprocess.PIPE).communicate()[0] + if len(out) == 0: + print(' (no trace in ', basename, ')') + continue + print(' (will check trace in ', basename, ')') + src = 'trace.cpp' + with open(src, 'wb') as o: + o.write(out) + expected = t + '.txt' + else: + src = t + expected = os.path.splitext(t)[0] + '.txt' + if not src.endswith(('.c', '.cpp')): + continue + # windows + gcc will need some work + if shared.skip_if_on_windows('gcc'): + return + # build the C file separately + extra = [os.environ.get('CC') or 'gcc', + src, '-c', '-o', 'example.o', + '-I' + os.path.join(shared.options.binaryen_root, 'src'), '-g', '-L' + libdir, '-pthread'] + print('build: ', ' '.join(extra)) + if src.endswith('.cpp'): + extra += ['-std=c++' + str(shared.cxx_standard)] + print(os.getcwd()) + subprocess.check_call(extra) + # Link against the binaryen C library DSO, using rpath + cmd = ['example.o', '-L' + libdir, '-lbinaryen', '-Wl,-rpath,' + os.path.abspath(libdir)] + cmd + print(' ', basename, src, expected) + if os.environ.get('COMPILER_FLAGS'): + for f in os.environ.get('COMPILER_FLAGS').split(' '): + cmd.append(f) + cmd = [os.environ.get('CXX') or 'g++', '-std=c++' + str(shared.cxx_standard)] + cmd + try: + print('link: ', ' '.join(cmd)) + subprocess.check_call(cmd) + print('run...', output_file) + proc = subprocess.Popen([output_file], stdout=subprocess.PIPE, stderr=subprocess.PIPE) + actual, err = proc.communicate() + assert proc.returncode == 0, [proc.returncode, actual, err] + with open(expected, 'wb') as o: + o.write(actual) + finally: + os.remove(output_file) + + +def update_wasm_dis_tests(): + print('\n[ checking wasm-dis on provided binaries... ]\n') + for t in shared.get_tests(shared.options.binaryen_test, ['.wasm']): + print('..', os.path.basename(t)) + cmd = shared.WASM_DIS + [t] + if os.path.isfile(t + '.map'): + cmd += ['--source-map', t + '.map'] + actual = support.run_command(cmd) + + open(t + '.fromBinary', 'w').write(actual) + + +def update_ctor_eval_tests(): + print('\n[ checking wasm-ctor-eval... ]\n') + for t in shared.get_tests(shared.get_test_dir('ctor-eval'), ['.wast', '.wasm']): + print('..', os.path.basename(t)) + ctors = open(t + '.ctors').read().strip() + cmd = shared.WASM_CTOR_EVAL + [t, '-all', '-o', 'a.wast', '-S', '--ctors', ctors] + support.run_command(cmd) + actual = open('a.wast').read() + out = t + '.out' + with open(out, 'w') as o: + o.write(actual) + + +def update_metadce_tests(): + print('\n[ checking wasm-metadce... ]\n') + for t in shared.get_tests(shared.get_test_dir('metadce'), ['.wast', '.wasm']): + print('..', os.path.basename(t)) + graph = t + '.graph.txt' + cmd = shared.WASM_METADCE + [t, '--graph-file=' + graph, '-o', 'a.wast', '-S', '-all'] + stdout = support.run_command(cmd) + actual = open('a.wast').read() + out = t + '.dced' + with open(out, 'w') as o: + o.write(actual) + with open(out + '.stdout', 'w') as o: + o.write(stdout) + + +def update_reduce_tests(): + print('\n[ checking wasm-reduce ]\n') + for t in shared.get_tests(shared.get_test_dir('reduce'), ['.wast']): + print('..', os.path.basename(t)) + # convert to wasm + support.run_command(shared.WASM_AS + [t, '-o', 'a.wasm']) + print(support.run_command(shared.WASM_REDUCE + ['a.wasm', '--command=%s b.wasm --fuzz-exec' % shared.WASM_OPT[0], '-t', 'b.wasm', '-w', 'c.wasm'])) + expected = t + '.txt' + support.run_command(shared.WASM_DIS + ['c.wasm', '-o', expected]) + + +def update_spec_tests(): + print('\n[ updating wasm-shell spec testcases... ]\n') + + for t in shared.options.spec_tests: + print('..', os.path.basename(t)) + + cmd = shared.WASM_SHELL + [t] + expected = os.path.join(shared.get_test_dir('spec'), 'expected-output', os.path.basename(t) + '.log') + if os.path.isfile(expected): + stdout = support.run_command(cmd, stderr=subprocess.PIPE) + # filter out binaryen interpreter logging that the spec suite + # doesn't expect + filtered = [line for line in stdout.splitlines() if not line.startswith('[trap')] + stdout = '\n'.join(filtered) + '\n' + with open(expected, 'w') as o: + o.write(stdout) + + +TEST_SUITES = OrderedDict([ + ('wasm-opt', wasm_opt.update_wasm_opt_tests), + ('wasm-dis', update_wasm_dis_tests), + ('example', update_example_tests), + ('ctor-eval', update_ctor_eval_tests), + ('wasm-metadce', update_metadce_tests), + ('wasm-reduce', update_reduce_tests), + ('spec', update_spec_tests), + ('lld', lld.update_lld_tests), + ('wasm2js', wasm2js.update_wasm2js_tests), + ('binaryenjs', binaryenjs.update_binaryen_js_tests), +]) + + +def main(): + all_suites = TEST_SUITES.keys() + skip_by_default = ['binaryenjs'] + + if shared.options.list_suites: + for suite in all_suites: + print(suite) + return 0 + + if not shared.requested: + shared.requested = [s for s in all_suites if s not in skip_by_default] + + for test in shared.requested: + TEST_SUITES[test]() + + print('\n[ success! ]') + + +if __name__ == '__main__': + sys.exit(main()) diff --git a/binaryen/check.py b/binaryen/check.py new file mode 100644 --- /dev/null +++ b/binaryen/check.py @@ -0,0 +1,405 @@ +#!/usr/bin/env python3 +# +# Copyright 2015 WebAssembly Community Group participants +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import glob +import os +import subprocess +import sys +import unittest +from collections import OrderedDict + +from scripts.test import binaryenjs +from scripts.test import lld +from scripts.test import shared +from scripts.test import support +from scripts.test import wasm2js +from scripts.test import wasm_opt + + +if shared.options.interpreter: + print('[ using wasm interpreter at "%s" ]' % shared.options.interpreter) + assert os.path.exists(shared.options.interpreter), 'interpreter not found' + + +def get_changelog_version(): + with open(os.path.join(shared.options.binaryen_root, 'CHANGELOG.md')) as f: + lines = f.readlines() + lines = [l for l in lines if len(l.split()) == 1] + lines = [l for l in lines if l.startswith('v')] + version = lines[0][1:] + print("Parsed CHANGELOG.md version: %s" % version) + return int(version) + + +def run_help_tests(): + print('[ checking --help is useful... ]\n') + + not_executable_suffix = ['.txt', '.js', '.ilk', '.pdb', '.dll', '.wasm', '.manifest'] + bin_files = [os.path.join(shared.options.binaryen_bin, f) for f in os.listdir(shared.options.binaryen_bin)] + executables = [f for f in bin_files if os.path.isfile(f) and not any(f.endswith(s) for s in not_executable_suffix)] + executables = sorted(executables) + assert len(executables) + + for e in executables: + print('.. %s --help' % e) + out, err = subprocess.Popen([e, '--help'], + stdout=subprocess.PIPE, + stderr=subprocess.PIPE).communicate() + out = out.decode('utf-8') + err = err.decode('utf-8') + assert len(err) == 0, 'Expected no stderr, got:\n%s' % err + assert os.path.basename(e).replace('.exe', '') in out, 'Expected help to contain program name, got:\n%s' % out + assert len(out.split('\n')) > 8, 'Expected some help, got:\n%s' % out + + print('[ checking --version ... ]\n') + changelog_version = get_changelog_version() + for e in executables: + print('.. %s --version' % e) + out, err = subprocess.Popen([e, '--version'], + stdout=subprocess.PIPE, + stderr=subprocess.PIPE).communicate() + out = out.decode('utf-8') + err = err.decode('utf-8') + assert len(err) == 0, 'Expected no stderr, got:\n%s' % err + assert os.path.basename(e).replace('.exe', '') in out, 'Expected version to contain program name, got:\n%s' % out + assert len(out.strip().splitlines()) == 1, 'Expected only version info, got:\n%s' % out + parts = out.split() + assert parts[1] == 'version' + version = int(parts[2]) + assert version == changelog_version + + +def run_wasm_dis_tests(): + print('\n[ checking wasm-dis on provided binaries... ]\n') + + for t in shared.get_tests(shared.options.binaryen_test, ['.wasm']): + print('..', os.path.basename(t)) + cmd = shared.WASM_DIS + [t] + if os.path.isfile(t + '.map'): + cmd += ['--source-map', t + '.map'] + + actual = support.run_command(cmd) + shared.fail_if_not_identical_to_file(actual, t + '.fromBinary') + + # also verify there are no validation errors + def check(): + cmd = shared.WASM_OPT + [t, '-all'] + support.run_command(cmd) + + shared.with_pass_debug(check) + + +def run_crash_tests(): + print("\n[ checking we don't crash on tricky inputs... ]\n") + + for t in shared.get_tests(shared.get_test_dir('crash'), ['.wast', '.wasm']): + print('..', os.path.basename(t)) + cmd = shared.WASM_OPT + [t] + # expect a parse error to be reported + support.run_command(cmd, expected_err='parse exception:', err_contains=True, expected_status=1) + + +def run_dylink_tests(): + print("\n[ we emit dylink sections properly... ]\n") + + dylink_tests = glob.glob(os.path.join(shared.options.binaryen_test, 'dylib*.wasm')) + for t in sorted(dylink_tests): + print('..', os.path.basename(t)) + cmd = shared.WASM_OPT + [t, '-o', 'a.wasm'] + support.run_command(cmd) + with open('a.wasm', 'rb') as output: + index = output.read().find(b'dylink') + print(' ', index) + assert index == 11, 'dylink section must be first, right after the magic number etc.' + + +def run_ctor_eval_tests(): + print('\n[ checking wasm-ctor-eval... ]\n') + + for t in shared.get_tests(shared.get_test_dir('ctor-eval'), ['.wast', '.wasm']): + print('..', os.path.basename(t)) + ctors = open(t + '.ctors').read().strip() + cmd = shared.WASM_CTOR_EVAL + [t, '-all', '-o', 'a.wat', '-S', '--ctors', ctors] + support.run_command(cmd) + actual = open('a.wat').read() + out = t + '.out' + shared.fail_if_not_identical_to_file(actual, out) + + +def run_wasm_metadce_tests(): + print('\n[ checking wasm-metadce ]\n') + + for t in shared.get_tests(shared.get_test_dir('metadce'), ['.wast', '.wasm']): + print('..', os.path.basename(t)) + graph = t + '.graph.txt' + cmd = shared.WASM_METADCE + [t, '--graph-file=' + graph, '-o', 'a.wat', '-S', '-all'] + stdout = support.run_command(cmd) + expected = t + '.dced' + with open('a.wat') as seen: + shared.fail_if_not_identical_to_file(seen.read(), expected) + shared.fail_if_not_identical_to_file(stdout, expected + '.stdout') + + +def run_wasm_reduce_tests(): + if not shared.has_shell_timeout(): + print('\n[ skipping wasm-reduce testcases]\n') + return + + print('\n[ checking wasm-reduce testcases]\n') + + # fixed testcases + for t in shared.get_tests(shared.get_test_dir('reduce'), ['.wast']): + print('..', os.path.basename(t)) + # convert to wasm + support.run_command(shared.WASM_AS + [t, '-o', 'a.wasm']) + support.run_command(shared.WASM_REDUCE + ['a.wasm', '--command=%s b.wasm --fuzz-exec --detect-features ' % shared.WASM_OPT[0], '-t', 'b.wasm', '-w', 'c.wasm', '--timeout=4']) + expected = t + '.txt' + support.run_command(shared.WASM_DIS + ['c.wasm', '-o', 'a.wat']) + with open('a.wat') as seen: + shared.fail_if_not_identical_to_file(seen.read(), expected) + + # run on a nontrivial fuzz testcase, for general coverage + # this is very slow in ThreadSanitizer, so avoid it there + if 'fsanitize=thread' not in str(os.environ): + print('\n[ checking wasm-reduce fuzz testcase ]\n') + # TODO: re-enable multivalue once it is better optimized + support.run_command(shared.WASM_OPT + [os.path.join(shared.options.binaryen_test, 'signext.wast'), '-ttf', '-Os', '-o', 'a.wasm', '--detect-features', '--disable-multivalue']) + before = os.stat('a.wasm').st_size + support.run_command(shared.WASM_REDUCE + ['a.wasm', '--command=%s b.wasm --fuzz-exec --detect-features' % shared.WASM_OPT[0], '-t', 'b.wasm', '-w', 'c.wasm']) + after = os.stat('c.wasm').st_size + # This number is a custom threshold to check if we have shrunk the + # output sufficiently + assert after < 0.85 * before, [before, after] + + +def run_spec_tests(): + print('\n[ checking wasm-shell spec testcases... ]\n') + + for wast in shared.options.spec_tests: + base = os.path.basename(wast) + print('..', base) + # windows has some failures that need to be investigated + if base == 'names.wast' and shared.skip_if_on_windows('spec: ' + base): + continue + + def run_spec_test(wast): + cmd = shared.WASM_SHELL + [wast] + output = support.run_command(cmd, stderr=subprocess.PIPE) + # filter out binaryen interpreter logging that the spec suite + # doesn't expect + filtered = [line for line in output.splitlines() if not line.startswith('[trap')] + return '\n'.join(filtered) + '\n' + + def run_opt_test(wast): + # check optimization validation + cmd = shared.WASM_OPT + [wast, '-O', '-all'] + support.run_command(cmd) + + def check_expected(actual, expected): + if expected and os.path.exists(expected): + expected = open(expected).read() + print(' (using expected output)') + actual = actual.strip() + expected = expected.strip() + if actual != expected: + shared.fail(actual, expected) + + expected = os.path.join(shared.get_test_dir('spec'), 'expected-output', base + '.log') + + # some spec tests should fail (actual process failure, not just assert_invalid) + try: + actual = run_spec_test(wast) + except Exception as e: + if ('wasm-validator error' in str(e) or 'parse exception' in str(e)) and '.fail.' in base: + print('<< test failed as expected >>') + continue # don't try all the binary format stuff TODO + else: + shared.fail_with_error(str(e)) + + check_expected(actual, expected) + + # skip binary checks for tests that reuse previous modules by name, as that's a wast-only feature + if 'exports.wast' in base: # FIXME + continue + + # check binary format. here we can verify execution of the final + # result, no need for an output verification + # some wast files cannot be split: + # * comments.wast: contains characters that are not valid utf-8, + # so our string splitting code fails there + + # FIXME Remove reference type tests from this list after nullref is + # implemented in V8 + if base not in ['comments.wast', 'ref_null.wast', 'ref_is_null.wast', 'ref_func.wast', 'old_select.wast']: + split_num = 0 + actual = '' + for module, asserts in support.split_wast(wast): + print(' testing split module', split_num) + split_num += 1 + support.write_wast('split.wast', module, asserts) + run_spec_test('split.wast') # before binary stuff - just check it's still ok split out + run_opt_test('split.wast') # also that our optimizer doesn't break on it + result_wast = shared.binary_format_check('split.wast', verify_final_result=False, original_wast=wast) + # add the asserts, and verify that the test still passes + open(result_wast, 'a').write('\n' + '\n'.join(asserts)) + actual += run_spec_test(result_wast) + # compare all the outputs to the expected output + check_expected(actual, os.path.join(shared.get_test_dir('spec'), 'expected-output', base + '.log')) + else: + # handle unsplittable wast files + run_spec_test(wast) + + +def run_validator_tests(): + print('\n[ running validation tests... ]\n') + # Ensure the tests validate by default + cmd = shared.WASM_AS + [os.path.join(shared.get_test_dir('validator'), 'invalid_export.wast'), '-o', 'a.wasm'] + support.run_command(cmd) + cmd = shared.WASM_AS + [os.path.join(shared.get_test_dir('validator'), 'invalid_import.wast'), '-o', 'a.wasm'] + support.run_command(cmd) + cmd = shared.WASM_AS + ['--validate=web', os.path.join(shared.get_test_dir('validator'), 'invalid_export.wast'), '-o', 'a.wasm'] + support.run_command(cmd, expected_status=1) + cmd = shared.WASM_AS + ['--validate=web', os.path.join(shared.get_test_dir('validator'), 'invalid_import.wast'), '-o', 'a.wasm'] + support.run_command(cmd, expected_status=1) + cmd = shared.WASM_AS + ['--validate=none', os.path.join(shared.get_test_dir('validator'), 'invalid_return.wast'), '-o', 'a.wasm'] + support.run_command(cmd) + cmd = shared.WASM_AS + [os.path.join(shared.get_test_dir('validator'), 'invalid_number.wast'), '-o', 'a.wasm'] + support.run_command(cmd, expected_status=1) + + +def run_gcc_tests(): + print('\n[ checking native gcc testcases...]\n') + if not shared.NATIVECC or not shared.NATIVEXX: + shared.fail_with_error('Native compiler (e.g. gcc/g++) was not found in PATH!') + return + # windows + gcc will need some work + if shared.skip_if_on_windows('gcc'): + return + + for t in sorted(os.listdir(shared.get_test_dir('example'))): + output_file = 'example' + cmd = ['-I' + os.path.join(shared.options.binaryen_root, 'src'), '-g', '-pthread', '-o', output_file] + if t.endswith('.txt'): + # check if there is a trace in the file, if so, we should build it + out = subprocess.check_output([os.path.join(shared.options.binaryen_root, 'scripts', 'clean_c_api_trace.py'), os.path.join(shared.get_test_dir('example'), t)]) + if len(out) == 0: + print(' (no trace in ', t, ')') + continue + print(' (will check trace in ', t, ')') + src = 'trace.cpp' + with open(src, 'wb') as o: + o.write(out) + expected = os.path.join(shared.get_test_dir('example'), t + '.txt') + else: + src = os.path.join(shared.get_test_dir('example'), t) + expected = os.path.join(shared.get_test_dir('example'), '.'.join(t.split('.')[:-1]) + '.txt') + if src.endswith(('.c', '.cpp')): + # build the C file separately + libpath = os.path.join(os.path.dirname(shared.options.binaryen_bin), 'lib') + extra = [shared.NATIVECC, src, '-c', '-o', 'example.o', + '-I' + os.path.join(shared.options.binaryen_root, 'src'), '-g', '-L' + libpath, '-pthread'] + if src.endswith('.cpp'): + extra += ['-std=c++' + str(shared.cxx_standard)] + if os.environ.get('COMPILER_FLAGS'): + for f in os.environ.get('COMPILER_FLAGS').split(' '): + extra.append(f) + print('build: ', ' '.join(extra)) + subprocess.check_call(extra) + # Link against the binaryen C library DSO, using an executable-relative rpath + cmd = ['example.o', '-L' + libpath, '-lbinaryen'] + cmd + ['-Wl,-rpath,' + libpath] + else: + continue + print(' ', t, src, expected) + if os.environ.get('COMPILER_FLAGS'): + for f in os.environ.get('COMPILER_FLAGS').split(' '): + cmd.append(f) + cmd = [shared.NATIVEXX, '-std=c++' + str(shared.cxx_standard)] + cmd + print('link: ', ' '.join(cmd)) + subprocess.check_call(cmd) + print('run...', output_file) + actual = subprocess.check_output([os.path.abspath(output_file)]).decode('utf-8') + os.remove(output_file) + shared.fail_if_not_identical_to_file(actual, expected) + + +def run_unittest(): + print('\n[ checking unit tests...]\n') + + # equivalent to `python -m unittest discover -s ./test -v` + suite = unittest.defaultTestLoader.discover(os.path.dirname(shared.options.binaryen_test)) + result = unittest.TextTestRunner(verbosity=2, failfast=shared.options.abort_on_first_failure).run(suite) + shared.num_failures += len(result.errors) + len(result.failures) + if shared.options.abort_on_first_failure and shared.num_failures: + raise Exception("unittest failed") + + +TEST_SUITES = OrderedDict([ + ('help-messages', run_help_tests), + ('wasm-opt', wasm_opt.test_wasm_opt), + ('wasm-dis', run_wasm_dis_tests), + ('crash', run_crash_tests), + ('dylink', run_dylink_tests), + ('ctor-eval', run_ctor_eval_tests), + ('wasm-metadce', run_wasm_metadce_tests), + ('wasm-reduce', run_wasm_reduce_tests), + ('spec', run_spec_tests), + ('lld', lld.test_wasm_emscripten_finalize), + ('wasm2js', wasm2js.test_wasm2js), + ('validator', run_validator_tests), + ('gcc', run_gcc_tests), + ('unit', run_unittest), + ('binaryenjs', binaryenjs.test_binaryen_js), + ('binaryenjs_wasm', binaryenjs.test_binaryen_wasm), +]) + + +# Run all the tests +def main(): + all_suites = TEST_SUITES.keys() + skip_by_default = ['binaryenjs', 'binaryenjs_wasm'] + + if shared.options.list_suites: + for suite in all_suites: + print(suite) + return 0 + + for r in shared.requested: + if r not in all_suites: + print('invalid test suite: %s (see --list-suites)\n' % r) + return 1 + + if not shared.requested: + shared.requested = [s for s in all_suites if s not in skip_by_default] + + for test in shared.requested: + TEST_SUITES[test]() + + # Check/display the results + if shared.num_failures == 0: + print('\n[ success! ]') + + if shared.warnings: + print('\n' + '\n'.join(shared.warnings)) + + if shared.num_failures > 0: + print('\n[ ' + str(shared.num_failures) + ' failures! ]') + return 1 + + return 0 + + +if __name__ == '__main__': + sys.exit(main()) diff --git a/binaryen/config.h.in b/binaryen/config.h.in new file mode 100644 --- /dev/null +++ b/binaryen/config.h.in @@ -0,0 +1,1 @@ +#cmakedefine PROJECT_VERSION "${PROJECT_VERSION}" diff --git a/binaryen/media/example.png b/binaryen/media/example.png new file mode 100644 Binary files /dev/null and b/binaryen/media/example.png differ diff --git a/binaryen/scripts/__init__.py b/binaryen/scripts/__init__.py new file mode 100644 --- /dev/null +++ b/binaryen/scripts/__init__.py @@ -0,0 +1,15 @@ +# Copyright 2015 WebAssembly Community Group participants +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# Empty __init__.py file: Python treats the directory as containing a package. diff --git a/binaryen/scripts/clang-format-diff.sh b/binaryen/scripts/clang-format-diff.sh new file mode 100644 --- /dev/null +++ b/binaryen/scripts/clang-format-diff.sh @@ -0,0 +1,28 @@ +#!/bin/bash + +set -o errexit + +# When we are running on travis and *not* part of a pull request we don't +# have any upstream branch to compare against. +if [ "$TRAVIS_PULL_REQUEST" = "false" ]; then + echo "Skipping since not running on travis PR" + exit 0 +fi + +if [ -n "$TRAVIS_BRANCH" ]; then + BRANCH=$TRAVIS_BRANCH +else + BRANCH=origin/master +fi + +MERGE_BASE=$(git merge-base $BRANCH HEAD) +FORMAT_MSG=$(git clang-format $MERGE_BASE -q --diff -- src/) +if [ -n "$FORMAT_MSG" -a "$FORMAT_MSG" != "no modified files to format" ] +then + echo "Please run git clang-format before committing, or apply this diff:" + echo + # Run git clang-format again, this time without capruting stdout. This way + # clang-format format the message nicely and add color. + git clang-format $MERGE_BASE -q --diff -- src/ + exit 1 +fi diff --git a/binaryen/scripts/clang-tidy-diff.sh b/binaryen/scripts/clang-tidy-diff.sh new file mode 100644 --- /dev/null +++ b/binaryen/scripts/clang-tidy-diff.sh @@ -0,0 +1,37 @@ +#!/bin/bash + +set -o errexit + +# When we are running on travis and *not* part of a pull request we don't +# have any upstream branch to compare against. +if [ "$TRAVIS_PULL_REQUEST" = "false" ]; then + echo "Skipping since not running on travis PR" + exit 0 +fi + +if [ -n "$TRAVIS_BRANCH" ]; then + BRANCH=$TRAVIS_BRANCH +else + BRANCH=origin/master +fi + +CLANG_TIDY=$(which clang-tidy) +if [ ! -e "$CLANG_TIDY" ]; then + echo "Failed to find clang-tidy ($CLANG_TIDY)" + exit 1 +fi + +CLANG_DIR=$(dirname $(dirname $(readlink -f $CLANG_TIDY))) +CLANG_TIDY_DIFF=$CLANG_DIR/share/clang/clang-tidy-diff.py +if [ ! -e "$CLANG_TIDY_DIFF" ]; then + echo "Failed to find clang-tidy-diff.py ($CLANG_TIDY_DIFF)" + exit 1 +fi +TIDY_MSG=$(git diff -U0 $BRANCH... | $CLANG_TIDY_DIFF -quiet -p1 2> /dev/null) +if [ -n "$TIDY_MSG" -a "$TIDY_MSG" != "No relevant changes found." ]; then + echo "Please fix clang-tidy errors before committing" + echo + # Run clang-tidy once again to show the error + git diff -U0 $BRANCH... | $CLANG_TIDY_DIFF -quiet -p1 2> /dev/null + exit 1 +fi diff --git a/binaryen/scripts/clean_c_api_trace.py b/binaryen/scripts/clean_c_api_trace.py new file mode 100644 --- /dev/null +++ b/binaryen/scripts/clean_c_api_trace.py @@ -0,0 +1,37 @@ +#!/usr/bin/env python3 +# +# Copyright 2016 WebAssembly Community Group participants +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Cleans up output from the C api, makes a runnable C file +""" + +import sys + +trace = open(sys.argv[1]).read() + +start = trace.find('// beginning a Binaryen API trace') +end = trace.rfind('// ending a Binaryen API trace') +if start >= 0: + trace = trace[start:end] + + while 1: + start = trace.find('\n(') + if start < 0: + break + end = trace.find('\n)', start + 1) + assert end > 0 + trace = trace[:start] + trace[end + 2:] + + print(trace) diff --git a/binaryen/scripts/embedwat.py b/binaryen/scripts/embedwat.py new file mode 100644 --- /dev/null +++ b/binaryen/scripts/embedwat.py @@ -0,0 +1,45 @@ +#!/usr/bin/env python3 +# +# Copyright 2018 WebAssembly Community Group participants +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import sys + +input_file = sys.argv[1] +output_file = sys.argv[2] + +with open(input_file) as f: + wat = f.read() + +output = """\ +// Automatically generated by embedwat.py + +#include "passes/intrinsics-module.h" + +static const char theModule[%d] = { +""" % (len(wat) + 1) + +for c in wat: + output += str(ord(c)) + ', ' + +output += '''0 +}; + +namespace wasm { +const char* IntrinsicsModuleWast = theModule; +} +''' + +with open(output_file, 'w') as f: + f.write(output) diff --git a/binaryen/scripts/emcc-tests.sh b/binaryen/scripts/emcc-tests.sh new file mode 100644 --- /dev/null +++ b/binaryen/scripts/emcc-tests.sh @@ -0,0 +1,17 @@ +#!/usr/bin/env bash + +set -e + +mkdir -p emcc-build +echo "emcc-tests: build:wasm" +emcmake cmake -B emcc-build -DCMAKE_BUILD_TYPE=Release -G Ninja +ninja -C emcc-build binaryen_wasm +echo "emcc-tests: test:wasm" +./check.py --binaryen-bin=emcc-build/bin binaryenjs_wasm +echo "emcc-tests: done:wasm" + +echo "emcc-tests: build:js" +ninja -C emcc-build binaryen_js +echo "emcc-tests: test:js" +./check.py --binaryen-bin=emcc-build/bin binaryenjs +echo "emcc-tests: done:js" diff --git a/binaryen/scripts/fuzz_opt.py b/binaryen/scripts/fuzz_opt.py new file mode 100644 --- /dev/null +++ b/binaryen/scripts/fuzz_opt.py @@ -0,0 +1,1058 @@ +#!/usr/bin/python3 + +''' +Runs random passes and options on random inputs, using wasm-opt. + +Can be configured to run just wasm-opt itself (using --fuzz-exec) +or also run VMs on it. + +For afl-fuzz integration, you probably don't want this, and can use +something like + +BINARYEN_CORES=1 BINARYEN_PASS_DEBUG=1 afl-fuzz -i afl-testcases/ -o afl-findings/ -m 100 -d -- bin/wasm-opt -ttf --fuzz-exec --Os @@ + +(that is on a fixed set of arguments to wasm-opt, though - this +script covers different options being passed) +''' + +import contextlib +import os +import difflib +import math +import shutil +import subprocess +import random +import re +import sys +import time +import traceback + +from test import shared + +assert sys.version_info.major == 3, 'requires Python 3!' + +# parameters + +# feature options that are always passed to the tools. +# * multivalue: https://github.com/WebAssembly/binaryen/issues/2770 +CONSTANT_FEATURE_OPTS = ['--all-features'] + +INPUT_SIZE_MIN = 1024 +INPUT_SIZE_MEAN = 40 * 1024 +INPUT_SIZE_MAX = 5 * INPUT_SIZE_MEAN + +PRINT_WATS = False + + +# utilities + +def in_binaryen(*args): + return os.path.join(shared.options.binaryen_root, *args) + + +def in_bin(tool): + return os.path.join(shared.options.binaryen_bin, tool) + + +def random_size(): + if random.random() < 0.25: + # sometimes do an exponential distribution, which prefers smaller sizes but may + # also get very high + ret = int(random.expovariate(1.0 / INPUT_SIZE_MEAN)) + # if the result is valid, use it, otherwise do the normal thing + # (don't clamp, which would give us a lot of values on the borders) + if ret >= INPUT_SIZE_MIN and ret <= INPUT_SIZE_MAX: + return ret + + # most of the time do a simple linear range around the mean + return random.randint(INPUT_SIZE_MIN, 2 * INPUT_SIZE_MEAN - INPUT_SIZE_MIN) + + +def run(cmd): + print(' '.join(cmd)) + return subprocess.check_output(cmd, text=True) + + +def run_unchecked(cmd): + print(' '.join(cmd)) + return subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True).communicate()[0] + + +def randomize_pass_debug(): + if random.random() < 0.1: + print('[pass-debug]') + os.environ['BINARYEN_PASS_DEBUG'] = '1' + else: + os.environ['BINARYEN_PASS_DEBUG'] = '0' + del os.environ['BINARYEN_PASS_DEBUG'] + print('randomized pass debug:', os.environ.get('BINARYEN_PASS_DEBUG', '')) + + +@contextlib.contextmanager +def no_pass_debug(): + old_env = os.environ.copy() + if os.environ.get('BINARYEN_PASS_DEBUG'): + del os.environ['BINARYEN_PASS_DEBUG'] + try: + yield + finally: + os.environ.update(old_env) + + +def randomize_feature_opts(): + global FEATURE_OPTS + FEATURE_OPTS = CONSTANT_FEATURE_OPTS[:] + # half the time apply all the possible opts. this lets all test runners work at max + # capacity at least half the time, as otherwise if they need almost all the opts, the + # chance of getting them is exponentially small. + if random.random() < 0.5: + FEATURE_OPTS += POSSIBLE_FEATURE_OPTS + else: + for possible in POSSIBLE_FEATURE_OPTS: + if random.random() < 0.5: + FEATURE_OPTS.append(possible) + if possible in IMPLIED_FEATURE_OPTS: + FEATURE_OPTS.extend(IMPLIED_FEATURE_OPTS[possible]) + print('randomized feature opts:', ' '.join(FEATURE_OPTS)) + + +FUZZ_OPTS = None +NANS = None +OOB = None +LEGALIZE = None +ORIGINAL_V8_OPTS = shared.V8_OPTS[:] + + +def randomize_fuzz_settings(): + global FUZZ_OPTS, NANS, OOB, LEGALIZE + FUZZ_OPTS = [] + if random.random() < 0.5: + NANS = True + else: + NANS = False + FUZZ_OPTS += ['--denan'] + if random.random() < 0.5: + OOB = True + else: + OOB = False + FUZZ_OPTS += ['--no-fuzz-oob'] + if random.random() < 0.5: + LEGALIZE = True + FUZZ_OPTS += ['--legalize-js-interface'] + else: + LEGALIZE = False + extra_v8_opts = [] + # 50% of the time test v8 normally, that is, the same way it runs in + # production (which as of 07/15/2020 means baseline, then tier up to + # optimizing, but that may change in the future). + if random.random() < 0.5: + # test either the optimizing compiler or the baseline compiler, with + # equal probability. it's useful to do this because the normal tier-up + # mode does not check them both equally (typically baseline does not get + # enough testing, as we quickly leave it), and also because the tiering + # up is nondeterministic (when optimized code becomes ready, we switch + # to it) + if random.random() < 0.5: + extra_v8_opts += ['--no-liftoff'] + else: + extra_v8_opts += ['--liftoff', '--no-wasm-tier-up'] + shared.V8_OPTS = ORIGINAL_V8_OPTS + extra_v8_opts + print('randomized settings (NaNs, OOB, legalize, extra V8_OPTS):', NANS, OOB, LEGALIZE, extra_v8_opts) + + +# Test outputs we want to ignore are marked this way. +IGNORE = '[binaryen-fuzzer-ignore]' + +# Traps are reported as [trap REASON] +TRAP_PREFIX = '[trap ' + +# --fuzz-exec reports calls as [fuzz-exec] calling foo +FUZZ_EXEC_CALL_PREFIX = '[fuzz-exec] calling' + + +# compare two strings, strictly +def compare(x, y, context): + if x != y and x != IGNORE and y != IGNORE: + message = ''.join([a + '\n' for a in difflib.unified_diff(x.splitlines(), y.splitlines(), fromfile='expected', tofile='actual')]) + raise Exception(context + " comparison error, expected to have '%s' == '%s', diff:\n\n%s" % ( + x, y, + message + )) + + +# numbers are "close enough" if they just differ in printing, as different +# vms may print at different precision levels and verbosity +def numbers_are_close_enough(x, y): + # handle nan comparisons like -nan:0x7ffff0 vs NaN, ignoring the bits + if 'nan' in x.lower() and 'nan' in y.lower(): + return True + # float() on the strings will handle many minor differences, like + # float('1.0') == float('1') , float('inf') == float('Infinity'), etc. + try: + return float(x) == float(y) + except Exception: + pass + # otherwise, try a full eval which can handle i64s too + try: + ex = eval(x) + ey = eval(y) + return ex == ey or float(ex) == float(ey) + except Exception as e: + print('failed to check if numbers are close enough:', e) + return False + + +# compare between vms, which may slightly change how numbers are printed +def compare_between_vms(x, y, context): + x_lines = x.splitlines() + y_lines = y.splitlines() + if len(x_lines) != len(y_lines): + return compare(x, y, context + ' (note: different number of lines between vms)') + + num_lines = len(x_lines) + for i in range(num_lines): + x_line = x_lines[i] + y_line = y_lines[i] + if x_line != y_line: + # this is different, but maybe it's a vm difference we can ignore + LEI_LOGGING = '[LoggingExternalInterface logging' + if x_line.startswith(LEI_LOGGING) and y_line.startswith(LEI_LOGGING): + x_val = x_line[len(LEI_LOGGING) + 1:-1] + y_val = y_line[len(LEI_LOGGING) + 1:-1] + if numbers_are_close_enough(x_val, y_val): + continue + NOTE_RESULT = '[fuzz-exec] note result' + if x_line.startswith(NOTE_RESULT) and y_line.startswith(NOTE_RESULT): + x_val = x_line.split(' ')[-1] + y_val = y_line.split(' ')[-1] + if numbers_are_close_enough(x_val, y_val): + continue + + # this failed to compare. print a custom diff of the relevant lines + MARGIN = 3 + start = max(i - MARGIN, 0) + end = min(i + MARGIN, num_lines) + return compare('\n'.join(x_lines[start:end]), '\n'.join(y_lines[start:end]), context) + + +def fix_output(out): + # large doubles may print slightly different on different VMs + def fix_double(x): + x = x.group(1) + if 'nan' in x or 'NaN' in x: + x = 'nan' + else: + x = x.replace('Infinity', 'inf') + x = str(float(x)) + return 'f64.const ' + x + out = re.sub(r'f64\.const (-?[nanN:abcdefxIity\d+-.]+)', fix_double, out) + # mark traps from wasm-opt as exceptions, even though they didn't run in a vm + out = out.replace(TRAP_PREFIX, 'exception: ' + TRAP_PREFIX) + lines = out.splitlines() + for i in range(len(lines)): + line = lines[i] + if 'Warning: unknown flag' in line or 'Try --help for options' in line: + # ignore some VM warnings that don't matter, like if a newer V8 has + # removed a flag that is no longer needed. but print the line so the + # developer can see it. + print(line) + lines[i] = None + elif 'exception' in line: + # exceptions may differ when optimizing, but an exception should + # occur, so ignore their types (also js engines print them out + # slightly differently) + lines[i] = ' *exception*' + return '\n'.join([line for line in lines if line is not None]) + + +def fix_spec_output(out): + out = fix_output(out) + # spec shows a pointer when it traps, remove that + out = '\n'.join(map(lambda x: x if 'runtime trap' not in x else x[x.find('runtime trap'):], out.splitlines())) + # https://github.com/WebAssembly/spec/issues/543 , float consts are messed up + out = '\n'.join(map(lambda x: x if 'f32' not in x and 'f64' not in x else '', out.splitlines())) + return out + + +def run_vm(cmd): + # ignore some vm assertions, if bugs have already been filed + known_issues = [ + 'local count too large', # ignore this; can be caused by flatten, ssa, etc. passes + ] + try: + return run(cmd) + except subprocess.CalledProcessError: + output = run_unchecked(cmd) + for issue in known_issues: + if issue in output: + return IGNORE + raise + + +MAX_INTERPRETER_ENV_VAR = 'BINARYEN_MAX_INTERPRETER_DEPTH' +MAX_INTERPRETER_DEPTH = 1000 + + +def run_bynterp(wasm, args): + # increase the interpreter stack depth, to test more things + os.environ[MAX_INTERPRETER_ENV_VAR] = str(MAX_INTERPRETER_DEPTH) + try: + return run_vm([in_bin('wasm-opt'), wasm] + FEATURE_OPTS + args) + finally: + del os.environ['BINARYEN_MAX_INTERPRETER_DEPTH'] + + +def run_d8_js(js, args=[]): + return run_vm([shared.V8] + shared.V8_OPTS + [js] + (['--'] if args else []) + args) + + +def run_d8_wasm(wasm): + return run_d8_js(in_binaryen('scripts', 'fuzz_shell.js'), [wasm]) + + +class TestCaseHandler: + # how frequent this handler will be run. 1 means always run it, 0.5 means half the + # time + frequency = 1 + + def __init__(self): + self.num_runs = 0 + + # If the core handle_pair() method is not overridden, it calls handle() on + # each of the items. That is useful if you just want the two wasms and don't + # care about their relationship. + def handle_pair(self, input, before_wasm, after_wasm, opts): + self.handle(before_wasm) + self.handle(after_wasm) + + def can_run_on_feature_opts(self, feature_opts): + return True + + def increment_runs(self): + self.num_runs += 1 + + def count_runs(self): + return self.num_runs + + +# Run VMs and compare results + +class VM: + def __init__(self, name, run, can_compare_to_self, can_compare_to_others): + self.name = name + self.run = run + self.can_compare_to_self = can_compare_to_self + self.can_compare_to_others = can_compare_to_others + + def can_run(self, wasm): + return True + + +# Fuzz the interpreter with --fuzz-exec. +class FuzzExec(TestCaseHandler): + frequency = 1 + + def handle_pair(self, input, before_wasm, after_wasm, opts): + run([in_bin('wasm-opt'), before_wasm] + opts + ['--fuzz-exec']) + + +class CompareVMs(TestCaseHandler): + frequency = 0.6 + + def __init__(self): + super(CompareVMs, self).__init__() + + def byn_run(wasm): + return run_bynterp(wasm, ['--fuzz-exec-before']) + + def v8_run(wasm): + run([in_bin('wasm-opt'), wasm, '--emit-js-wrapper=' + wasm + '.js'] + FEATURE_OPTS) + return run_vm([shared.V8, wasm + '.js'] + shared.V8_OPTS + ['--', wasm]) + + def yes(): + return True + + def if_legal_and_no_nans(): + return LEGALIZE and not NANS + + def if_no_nans(): + return not NANS + + class Wasm2C(VM): + name = 'wasm2c' + + def __init__(self): + # look for wabt in the path. if it's not here, don't run wasm2c + try: + wabt_bin = shared.which('wasm2c') + wabt_root = os.path.dirname(os.path.dirname(wabt_bin)) + self.wasm2c_dir = os.path.join(wabt_root, 'wasm2c') + if not os.path.isdir(self.wasm2c_dir): + print('wabt found, but not wasm2c support dir') + self.wasm2c_dir = None + except Exception as e: + print('warning: no wabt found:', e) + self.wasm2c_dir = None + + def can_run(self, wasm): + if self.wasm2c_dir is None: + return False + # if we legalize for JS, the ABI is not what C wants + if LEGALIZE: + return False + # relatively slow, so run it less frequently + if random.random() < 0.5: + return False + # wasm2c doesn't support most features + return all([x in FEATURE_OPTS for x in ['--disable-exception-handling', '--disable-simd', '--disable-threads', '--disable-bulk-memory', '--disable-nontrapping-float-to-int', '--disable-tail-call', '--disable-sign-ext', '--disable-reference-types', '--disable-multivalue', '--disable-gc']]) + + def run(self, wasm): + run([in_bin('wasm-opt'), wasm, '--emit-wasm2c-wrapper=main.c'] + FEATURE_OPTS) + run(['wasm2c', wasm, '-o', 'wasm.c']) + compile_cmd = ['clang', 'main.c', 'wasm.c', os.path.join(self.wasm2c_dir, 'wasm-rt-impl.c'), '-I' + self.wasm2c_dir, '-lm', '-Werror'] + run(compile_cmd) + return run_vm(['./a.out']) + + def can_compare_to_self(self): + # The binaryen optimizer changes NaNs in the ways that wasm + # expects, but that's not quite what C has + return not NANS + + def can_compare_to_others(self): + # C won't trap on OOB, and NaNs can differ from wasm VMs + return not OOB and not NANS + + class Wasm2C2Wasm(Wasm2C): + name = 'wasm2c2wasm' + + def __init__(self): + super(Wasm2C2Wasm, self).__init__() + + self.has_emcc = shared.which('emcc') is not None + + def run(self, wasm): + run([in_bin('wasm-opt'), wasm, '--emit-wasm2c-wrapper=main.c'] + FEATURE_OPTS) + run(['wasm2c', wasm, '-o', 'wasm.c']) + compile_cmd = ['emcc', 'main.c', 'wasm.c', os.path.join(self.wasm2c_dir, 'wasm-rt-impl.c'), '-I' + self.wasm2c_dir, '-lm'] + # disable the signal handler: emcc looks like unix, but wasm has + # no signals + compile_cmd += ['-DWASM_RT_MEMCHECK_SIGNAL_HANDLER=0'] + if random.random() < 0.5: + compile_cmd += ['-O' + str(random.randint(1, 3))] + elif random.random() < 0.5: + if random.random() < 0.5: + compile_cmd += ['-Os'] + else: + compile_cmd += ['-Oz'] + # avoid pass-debug on the emcc invocation itself (which runs + # binaryen to optimize the wasm), as the wasm here can be very + # large and it isn't what we are focused on testing here + with no_pass_debug(): + run(compile_cmd) + return run_d8_js('a.out.js') + + def can_run(self, wasm): + # quite slow (more steps), so run it less frequently + if random.random() < 0.8: + return False + # prefer not to run if the wasm is very large, as it can OOM + # the JS engine. + return super(Wasm2C2Wasm, self).can_run(wasm) and self.has_emcc and \ + os.path.getsize(wasm) <= INPUT_SIZE_MEAN + + def can_compare_to_others(self): + # NaNs can differ from wasm VMs + return not NANS + + self.vms = [ + VM('binaryen interpreter', byn_run, can_compare_to_self=yes, can_compare_to_others=yes), + # with nans, VM differences can confuse us, so only very simple VMs can compare to themselves after opts in that case. + # if not legalized, the JS will fail immediately, so no point to compare to others + VM('d8', v8_run, can_compare_to_self=if_no_nans, can_compare_to_others=if_legal_and_no_nans), + Wasm2C(), + Wasm2C2Wasm(), + ] + + def handle_pair(self, input, before_wasm, after_wasm, opts): + before = self.run_vms(before_wasm) + after = self.run_vms(after_wasm) + self.compare_before_and_after(before, after) + + def run_vms(self, wasm): + # vm_results will map vms to their results + vm_results = {} + for vm in self.vms: + if vm.can_run(wasm): + vm_results[vm] = fix_output(vm.run(wasm)) + + # compare between the vms on this specific input + + first_vm = None + for vm in vm_results.keys(): + if vm.can_compare_to_others(): + if first_vm is None: + first_vm = vm + else: + compare_between_vms(vm_results[first_vm], vm_results[vm], 'CompareVMs between VMs: ' + first_vm.name + ' and ' + vm.name) + + return vm_results + + def compare_before_and_after(self, before, after): + # compare each VM to itself on the before and after inputs + for vm in before.keys(): + if vm in after and vm.can_compare_to_self(): + compare(before[vm], after[vm], 'CompareVMs between before and after: ' + vm.name) + + def can_run_on_feature_opts(self, feature_opts): + return all([x in feature_opts for x in ['--disable-simd', '--disable-reference-types', '--disable-exception-handling', '--disable-multivalue', '--disable-gc']]) + + +# Check for determinism - the same command must have the same output. +class CheckDeterminism(TestCaseHandler): + # not that important + frequency = 0.1 + + def handle_pair(self, input, before_wasm, after_wasm, opts): + # check for determinism + run([in_bin('wasm-opt'), before_wasm, '-o', 'b1.wasm'] + opts) + run([in_bin('wasm-opt'), before_wasm, '-o', 'b2.wasm'] + opts) + assert open('b1.wasm', 'rb').read() == open('b2.wasm', 'rb').read(), 'output must be deterministic' + + +class Wasm2JS(TestCaseHandler): + frequency = 0.6 + + def handle_pair(self, input, before_wasm, after_wasm, opts): + before_wasm_temp = before_wasm + '.temp.wasm' + after_wasm_temp = after_wasm + '.temp.wasm' + # legalize the before wasm, so that comparisons to the interpreter + # later make sense (if we don't do this, the wasm may have i64 exports). + # after applying other necessary fixes, we'll recreate the after wasm + # from scratch. + run([in_bin('wasm-opt'), before_wasm, '--legalize-js-interface', '-o', before_wasm_temp] + FEATURE_OPTS) + compare_before_to_after = random.random() < 0.5 + compare_to_interpreter = compare_before_to_after and random.random() < 0.5 + if compare_before_to_after: + # to compare the wasm before and after optimizations, we must + # remove operations that wasm2js does not support with full + # precision, such as i64-to-f32, as the optimizer can give different + # results. + simplification_passes = ['--stub-unsupported-js'] + if compare_to_interpreter: + # unexpectedly-unaligned loads/stores work fine in wasm in general but + # not in wasm2js, since typed arrays silently round down, effectively. + # if we want to compare to the interpreter, remove unaligned + # operations (by forcing alignment 1, then lowering those into aligned + # components, which means all loads and stores are of a single byte). + simplification_passes += ['--dealign', '--alignment-lowering'] + run([in_bin('wasm-opt'), before_wasm_temp, '-o', before_wasm_temp] + simplification_passes + FEATURE_OPTS) + # now that the before wasm is fixed up, generate a proper after wasm + run([in_bin('wasm-opt'), before_wasm_temp, '-o', after_wasm_temp] + opts + FEATURE_OPTS) + # always check for compiler crashes + before = self.run(before_wasm_temp) + after = self.run(after_wasm_temp) + if NANS: + # with NaNs we can't compare the output, as a reinterpret through + # memory might end up different in JS than wasm + return + # we also cannot compare if the wasm hits a trap, as wasm2js does not + # trap on many things wasm would, and in those cases it can do weird + # undefined things. in such a case, at least compare up until before + # the trap, which lets us compare at least some results in some cases. + # (this is why wasm2js is not in CompareVMs, which does full + # comparisons - we need to limit the comparison in a special way here) + interpreter = run([in_bin('wasm-opt'), before_wasm_temp, '--fuzz-exec-before']) + if TRAP_PREFIX in interpreter: + trap_index = interpreter.index(TRAP_PREFIX) + # we can't test this function, which the trap is in the middle of. + # erase everything from this function's output and onward, so we + # only compare the previous trap-free code + call_start = interpreter.rindex(FUZZ_EXEC_CALL_PREFIX, 0, trap_index) + call_end = interpreter.index('\n', call_start) + call_line = interpreter[call_start:call_end] + before = before[:before.index(call_line)] + after = after[:after.index(call_line)] + interpreter = interpreter[:interpreter.index(call_line)] + + def fix_output_for_js(x): + # start with the normal output fixes that all VMs need + x = fix_output(x) + + # check if a number is 0 or a subnormal, which is basically zero + def is_basically_zero(x): + # to check if something is a subnormal, compare it to the largest one + return x >= 0 and x <= 2.22507385850720088902e-308 + + def fix_number(x): + x = x.group(1) + try: + x = float(x) + # There appear to be some cases where JS VMs will print + # subnormals in full detail while other VMs do not, and vice + # versa. Ignore such really tiny numbers. + if is_basically_zero(x): + x = 0 + except ValueError: + # not a floating-point number, nothing to do + pass + return ' => ' + str(x) + + # logging notation is "function_name => result", look for that with + # a floating-point result that may need to be fixed up + return re.sub(r' => (-?[\d+-.e\-+]+)', fix_number, x) + + before = fix_output_for_js(before) + after = fix_output_for_js(after) + if compare_before_to_after: + compare_between_vms(before, after, 'Wasm2JS (before/after)') + if compare_to_interpreter: + interpreter = fix_output_for_js(interpreter) + compare_between_vms(before, interpreter, 'Wasm2JS (vs interpreter)') + + def run(self, wasm): + wrapper = run([in_bin('wasm-opt'), wasm, '--emit-js-wrapper=/dev/stdout'] + FEATURE_OPTS) + cmd = [in_bin('wasm2js'), wasm, '--emscripten'] + # avoid optimizations if we have nans, as we don't handle them with + # full precision and optimizations can change things + # OOB accesses are also an issue with optimizations, that can turn the + # loaded "undefined" into either 0 (with an |0) or stay undefined + # in optimized code. + if not NANS and not OOB and random.random() < 0.5: + # when optimizing also enable deterministic mode, to avoid things + # like integer divide by zero causing false positives (1 / 0 is + # Infinity without a | 0 , and 0 with one, and the truthiness of + # those differs; we don't want to care about this because it + # would trap in wasm anyhow) + cmd += ['-O', '--deterministic'] + main = run(cmd + FEATURE_OPTS) + with open(os.path.join(shared.options.binaryen_root, 'scripts', 'wasm2js.js')) as f: + glue = f.read() + js_file = wasm + '.js' + with open(js_file, 'w') as f: + f.write(glue) + f.write(main) + f.write(wrapper) + return run_vm([shared.NODEJS, js_file, 'a.wasm']) + + def can_run_on_feature_opts(self, feature_opts): + return all([x in feature_opts for x in ['--disable-exception-handling', '--disable-simd', '--disable-threads', '--disable-bulk-memory', '--disable-nontrapping-float-to-int', '--disable-tail-call', '--disable-sign-ext', '--disable-reference-types', '--disable-multivalue', '--disable-gc']]) + + +class Asyncify(TestCaseHandler): + frequency = 0.6 + + def handle_pair(self, input, before_wasm, after_wasm, opts): + # we must legalize in order to run in JS + run([in_bin('wasm-opt'), before_wasm, '--legalize-js-interface', '-o', 'async.' + before_wasm] + FEATURE_OPTS) + run([in_bin('wasm-opt'), after_wasm, '--legalize-js-interface', '-o', 'async.' + after_wasm] + FEATURE_OPTS) + before_wasm = 'async.' + before_wasm + after_wasm = 'async.' + after_wasm + before = fix_output(run_d8_wasm(before_wasm)) + after = fix_output(run_d8_wasm(after_wasm)) + + try: + compare(before, after, 'Asyncify (before/after)') + except Exception: + # if we failed to just compare the builds before asyncify even runs, + # then it may use NaNs or be sensitive to legalization; ignore it + print('ignoring due to pre-asyncify difference') + return + + def do_asyncify(wasm): + cmd = [in_bin('wasm-opt'), wasm, '--asyncify', '-o', 'async.t.wasm'] + # if we allow NaNs, running binaryen optimizations and then + # executing in d8 may lead to different results due to NaN + # nondeterminism between VMs. + if not NANS: + if random.random() < 0.5: + cmd += ['--optimize-level=%d' % random.randint(1, 3)] + if random.random() < 0.5: + cmd += ['--shrink-level=%d' % random.randint(1, 2)] + cmd += FEATURE_OPTS + run(cmd) + out = run_d8_wasm('async.t.wasm') + # ignore the output from the new asyncify API calls - the ones with asserts will trap, too + for ignore in ['[fuzz-exec] calling asyncify_start_unwind\nexception!\n', + '[fuzz-exec] calling asyncify_start_unwind\n', + '[fuzz-exec] calling asyncify_start_rewind\nexception!\n', + '[fuzz-exec] calling asyncify_start_rewind\n', + '[fuzz-exec] calling asyncify_stop_rewind\n', + '[fuzz-exec] calling asyncify_stop_unwind\n']: + out = out.replace(ignore, '') + out = '\n'.join([l for l in out.splitlines() if 'asyncify: ' not in l]) + return fix_output(out) + + before_asyncify = do_asyncify(before_wasm) + after_asyncify = do_asyncify(after_wasm) + + compare(before, before_asyncify, 'Asyncify (before/before_asyncify)') + compare(before, after_asyncify, 'Asyncify (before/after_asyncify)') + + def can_run_on_feature_opts(self, feature_opts): + return all([x in feature_opts for x in ['--disable-exception-handling', '--disable-simd', '--disable-tail-call', '--disable-reference-types', '--disable-multivalue', '--disable-gc']]) + + +# The global list of all test case handlers +testcase_handlers = [ + FuzzExec(), + CompareVMs(), + CheckDeterminism(), + Wasm2JS(), + Asyncify(), +] + + +# Do one test, given an input file for -ttf and some optimizations to run +def test_one(random_input, opts, given_wasm): + randomize_pass_debug() + randomize_feature_opts() + randomize_fuzz_settings() + print() + + if given_wasm: + # if given a wasm file we want to use it as is, but we also want to + # apply properties like not having any NaNs, which the original fuzz + # wasm had applied. that is, we need to preserve properties like not + # having nans through reduction. + run([in_bin('wasm-opt'), given_wasm, '-o', 'a.wasm'] + FUZZ_OPTS + FEATURE_OPTS) + else: + # emit the target features section so that reduction can work later, + # without needing to specify the features + generate_command = [in_bin('wasm-opt'), random_input, '-ttf', '-o', 'a.wasm', '--emit-target-features'] + FUZZ_OPTS + FEATURE_OPTS + if PRINT_WATS: + printed = run(generate_command + ['--print']) + with open('a.printed.wast', 'w') as f: + f.write(printed) + else: + run(generate_command) + wasm_size = os.stat('a.wasm').st_size + bytes = wasm_size + print('pre wasm size:', wasm_size) + + # create a second wasm for handlers that want to look at pairs. + generate_command = [in_bin('wasm-opt'), 'a.wasm', '-o', 'b.wasm'] + opts + FUZZ_OPTS + FEATURE_OPTS + if PRINT_WATS: + printed = run(generate_command + ['--print']) + with open('b.printed.wast', 'w') as f: + f.write(printed) + else: + run(generate_command) + wasm_size = os.stat('b.wasm').st_size + bytes += wasm_size + print('post wasm size:', wasm_size) + + # first, find which handlers can even run here + relevant_handlers = [handler for handler in testcase_handlers if not hasattr(handler, 'get_commands') and handler.can_run_on_feature_opts(FEATURE_OPTS)] + if len(relevant_handlers) == 0: + return 0 + # filter by frequency + filtered_handlers = [handler for handler in relevant_handlers if random.random() < handler.frequency] + if len(filtered_handlers) == 0: + # pick at least one, to not waste the effort we put into making the wasm + filtered_handlers = [random.choice(relevant_handlers)] + # run only some of the pair handling handlers. if we ran them all all the + # time that would mean we have less variety in wasm files and passes run + # on them in the same amount of time. + NUM_PAIR_HANDLERS = 3 + used_handlers = set() + for i in range(NUM_PAIR_HANDLERS): + testcase_handler = random.choice(filtered_handlers) + if testcase_handler in used_handlers: + continue + used_handlers.add(testcase_handler) + assert testcase_handler.can_run_on_feature_opts(FEATURE_OPTS) + print('running testcase handler:', testcase_handler.__class__.__name__) + testcase_handler.increment_runs() + + # let the testcase handler handle this testcase however it wants. in this case we give it + # the input and both wasms. + testcase_handler.handle_pair(input=random_input, before_wasm='a.wasm', after_wasm='b.wasm', opts=opts + FEATURE_OPTS) + print('') + + return bytes + + +def write_commands(commands, filename): + with open(filename, 'w') as f: + f.write('set -e\n') + for command in commands: + f.write('echo "%s"\n' % command) + pre = 'BINARYEN_PASS_DEBUG=%s ' % (os.environ.get('BINARYEN_PASS_DEBUG') or '0') + f.write(pre + command + ' &> /dev/null\n') + f.write('echo "ok"\n') + + +# main + +opt_choices = [ + [], + ['-O1'], ['-O2'], ['-O3'], ['-O4'], ['-Os'], ['-Oz'], + ["--coalesce-locals"], + # XXX slow, non-default ["--coalesce-locals-learning"], + ["--code-pushing"], + ["--code-folding"], + ["--const-hoisting"], + ["--dae"], + ["--dae-optimizing"], + ["--dce"], + ["--directize"], + ["--flatten", "--dfo"], + ["--duplicate-function-elimination"], + ["--flatten"], + # ["--fpcast-emu"], # removes indirect call failures as it makes them go through regardless of type + ["--inlining"], + ["--inlining-optimizing"], + ["--flatten", "--local-cse"], + ["--generate-stack-ir"], + ["--licm"], + ["--memory-packing"], + ["--merge-blocks"], + ['--merge-locals'], + ["--optimize-instructions"], + ["--optimize-stack-ir"], + ["--generate-stack-ir", "--optimize-stack-ir"], + ["--pick-load-signs"], + ["--precompute"], + ["--precompute-propagate"], + ["--print"], + ["--remove-unused-brs"], + ["--remove-unused-nonfunction-module-elements"], + ["--remove-unused-module-elements"], + ["--remove-unused-names"], + ["--reorder-functions"], + ["--reorder-locals"], + ["--flatten", "--rereloop"], + ["--roundtrip"], + ["--rse"], + ["--simplify-locals"], + ["--simplify-locals-nonesting"], + ["--simplify-locals-nostructure"], + ["--simplify-locals-notee"], + ["--simplify-locals-notee-nostructure"], + ["--ssa"], + ["--vacuum"], +] + + +def randomize_opt_flags(): + flag_groups = [] + has_flatten = False + # core opts + while 1: + choice = random.choice(opt_choices) + if '--flatten' in choice: + if has_flatten: + print('avoiding multiple --flatten in a single command, due to exponential overhead') + continue + else: + has_flatten = True + flag_groups.append(choice) + if len(flag_groups) > 20 or random.random() < 0.3: + break + # maybe add an extra round trip + if random.random() < 0.5: + pos = random.randint(0, len(flag_groups)) + flag_groups = flag_groups[:pos] + [['--roundtrip']] + flag_groups[pos:] + ret = [flag for group in flag_groups for flag in group] + # modifiers (if not already implied by a -O? option) + if '-O' not in str(ret): + if random.random() < 0.5: + ret += ['--optimize-level=' + str(random.randint(0, 3))] + if random.random() < 0.5: + ret += ['--shrink-level=' + str(random.randint(0, 3))] + assert ret.count('--flatten') <= 1 + return ret + + +# main + +# possible feature options that are sometimes passed to the tools. this +# contains the list of all possible feature flags we can disable (after +# we enable all before that in the constant options) +POSSIBLE_FEATURE_OPTS = run([in_bin('wasm-opt'), '--print-features', in_binaryen('test', 'hello_world.wat')] + CONSTANT_FEATURE_OPTS).replace('--enable', '--disable').strip().split('\n') +print('POSSIBLE_FEATURE_OPTS:', POSSIBLE_FEATURE_OPTS) + +# some features depend on other features, so if a required feature is +# disabled, its dependent features need to be disabled as well. +IMPLIED_FEATURE_OPTS = { + '--disable-reference-types': ['--disable-exception-handling', '--disable-gc'] +} + +if __name__ == '__main__': + # if we are given a seed, run exactly that one testcase. otherwise, + # run new ones until we fail + # if we are given a seed, we can also be given a wasm file, which we use + # instead of the randomly generating one. this can be useful for + # reduction. + given_wasm = None + if len(shared.requested) >= 1: + given_seed = int(shared.requested[0]) + print('checking a single given seed', given_seed) + if len(shared.requested) >= 2: + given_wasm = shared.requested[1] + print('using given wasm file', given_wasm) + else: + given_seed = None + print('checking infinite random inputs') + seed = time.time() * os.getpid() + raw_input_data = 'input.dat' + counter = 0 + total_wasm_size = 0 + total_input_size = 0 + total_input_size_squares = 0 + start_time = time.time() + while True: + counter += 1 + if given_seed is not None: + seed = given_seed + given_seed_passed = True + else: + seed = random.randint(0, 1 << 64) + random.seed(seed) + input_size = random_size() + total_input_size += input_size + total_input_size_squares += input_size ** 2 + print('') + mean = float(total_input_size) / counter + mean_of_squares = float(total_input_size_squares) / counter + stddev = math.sqrt(mean_of_squares - (mean ** 2)) + elapsed = max(0.000001, time.time() - start_time) + print('ITERATION:', counter, 'seed:', seed, 'size:', input_size, + '(mean:', str(mean) + ', stddev:', str(stddev) + ')', + 'speed:', counter / elapsed, + 'iters/sec, ', total_wasm_size / elapsed, + 'wasm_bytes/sec\n') + with open(raw_input_data, 'wb') as f: + f.write(bytes([random.randint(0, 255) for x in range(input_size)])) + assert os.path.getsize(raw_input_data) == input_size + opts = randomize_opt_flags() + print('randomized opts:', ' '.join(opts)) + try: + total_wasm_size += test_one(raw_input_data, opts, given_wasm) + except KeyboardInterrupt: + print('(stopping by user request)') + break + except Exception as e: + # print the exception manually, so that we can show our message at + # the very end where it won't be missed + ex_type, ex, tb = sys.exc_info() + print('!') + print('-----------------------------------------') + print('Exception:') + traceback.print_tb(tb) + print('-----------------------------------------') + print('!') + for arg in e.args: + print(arg) + if given_seed is not None: + given_seed_passed = False + + # We want to generate a template reducer script only when there is + # no given wasm file. That we have a given wasm file means we are no + # longer working on the original test case but modified one, which + # is likely to be called within wasm-reduce script itself, so + # original.wasm and reduce.sh should not be overwritten. + if not given_wasm: + # show some useful info about filing a bug and reducing the + # testcase (to make reduction simple, save "original.wasm" on + # the side, so that we can autoreduce using the name "a.wasm" + # which we use internally) + original_wasm = os.path.abspath('original.wasm') + shutil.copyfile('a.wasm', original_wasm) + # write out a useful reduce.sh + with open('reduce.sh', 'w') as reduce_sh: + reduce_sh.write('''\ +# check the input is even a valid wasm file +%(wasm_opt)s --detect-features %(temp_wasm)s +echo "should be 0:" $? + +# run the command +./scripts/fuzz_opt.py --binaryen-bin %(bin)s %(seed)d %(temp_wasm)s > o 2> e +echo "should be 1:" $? + +# +# You may want to print out part of "o" or "e", if the output matters and not +# just the return code. For example, +# +# cat o | tail -n 10 +# +# would print out the last few lines of stdout, which might be useful if that +# mentions the specific error you want. Make sure that includes the right +# details (sometimes stderr matters too), and preferably no more (less details +# allow more reduction, but raise the risk of it reducing to something you don't +# quite want). +# +# To do a "dry run" of what the reducer will do, copy the original file to the +# test file that this script will run on, +# +# cp %(original_wasm)s %(temp_wasm)s +# +# and then run +# +# bash %(reduce_sh)s +# +# You may also need to add --timeout 5 or such if the testcase is a slow one. +# + ''' % {'wasm_opt': in_bin('wasm-opt'), + 'bin': shared.options.binaryen_bin, + 'seed': seed, + 'original_wasm': original_wasm, + 'temp_wasm': os.path.abspath('t.wasm'), + 'reduce_sh': os.path.abspath('reduce.sh')}) + + print('''\ +================================================================================ +You found a bug! Please report it with + + seed: %(seed)d + +and the exact version of Binaryen you found it on, plus the exact Python +version (hopefully deterministic random numbers will be identical). + +You can run that testcase again with "fuzz_opt.py %(seed)d" + +The initial wasm file used here is saved as %(original_wasm)s + +You can reduce the testcase by running this now: + +|||| +vvvv + + +%(wasm_reduce)s %(original_wasm)s '--command=bash %(reduce_sh)s' -t %(temp_wasm)s -w %(working_wasm)s + + +^^^^ +|||| + +Make sure to verify by eye that the output says + +should be 0: 0 +should be 1: 1 + +You can also read "%(reduce_sh)s" which has been filled out for you and includes +docs and suggestions. + +After reduction, the reduced file will be in %(working_wasm)s +================================================================================ + ''' % {'seed': seed, + 'original_wasm': original_wasm, + 'temp_wasm': os.path.abspath('t.wasm'), + 'working_wasm': os.path.abspath('w.wasm'), + 'wasm_reduce': in_bin('wasm-reduce'), + 'reduce_sh': os.path.abspath('reduce.sh')}) + break + if given_seed is not None: + break + + print('\nInvocations so far:') + for testcase_handler in testcase_handlers: + print(' ', testcase_handler.__class__.__name__ + ':', testcase_handler.count_runs()) + + if given_seed is not None: + if given_seed_passed: + print('(finished running seed %d without error)' % given_seed) + sys.exit(0) + else: + print('(finished running seed %d, see error above)' % given_seed) + sys.exit(1) diff --git a/binaryen/scripts/fuzz_passes.py b/binaryen/scripts/fuzz_passes.py new file mode 100644 --- /dev/null +++ b/binaryen/scripts/fuzz_passes.py @@ -0,0 +1,147 @@ +#!/usr/bin/env python3 +# +# Copyright 2016 WebAssembly Community Group participants +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +''' +This fuzzes passes, by starting with a working program, then running +random passes on the wast, and seeing if they break something + +Usage: Provide a base filename for a runnable program, e.g. a.out.js. + Then we will modify a.out.wast. Note that the program must + be built to run using that wast (BINARYEN_METHOD=interpret-s-expr) + + Other parameters after the first are used when calling the program. +''' + +from __future__ import print_function + +import os +import random +import shutil +import subprocess +import sys + +PASSES = [ + "duplicate-function-elimination", + "dce", + "remove-unused-brs", + "remove-unused-names", + "optimize-instructions", + "precompute", + "simplify-locals", + "vacuum", + "coalesce-locals", + "reorder-locals", + "merge-blocks", + "remove-unused-functions", +] + +# main + +base = sys.argv[1] +wast = base[:-3] + '.wast' +print('>>> base program:', base, ', wast:', wast) + +args = sys.argv[2:] + + +def run(): + if os.path.exists(wast): + print('>>> running using a wast of size', os.stat(wast).st_size) + cmd = ['mozjs', base] + args + try: + return subprocess.check_output(cmd, stderr=subprocess.STDOUT) + except Exception as e: + print(">>> !!! ", e, " !!!") + + +original_wast = None + +try: + # get normal output + + normal = run() + print('>>> normal output:\n', normal) + assert normal, 'must be output' + + # ensure we actually use the wast + + original_wast = wast + '.original.wast' + shutil.move(wast, original_wast) + assert run() != normal, 'running without the wast must fail' + + # ensure a bad pass makes it fail + + def apply_passes(passes): + wasm_opt = os.path.join('bin', 'wasm-opt') + subprocess.check_call([wasm_opt, original_wast] + passes + ['-o', wast]) + + apply_passes(['--remove-imports']) + assert run() != normal, 'running after a breaking pass must fail' + + # loop, looking for failures + + def simplify(passes): + # passes is known to fail, try to simplify down by removing + more = True + while more: + more = False + print('>>> trying to reduce:', ' '.join(passes), ' [' + str(len(passes)) + ']') + for i in range(len(passes)): + smaller = passes[:i] + passes[i + 1:] + print('>>>>>> try to reduce to:', ' '.join(smaller), ' [' + str(len(smaller)) + ']') + try: + apply_passes(smaller) + assert run() == normal + except Exception: + # this failed too, so it's a good reduction + passes = smaller + print('>>> reduction successful') + more = True + break + print('>>> reduced to:', ' '.join(passes)) + + tested = set() + + def pick_passes(): + ret = [] + while 1: + str_ret = str(ret) + if random.random() < 0.1 and str_ret not in tested: + tested.add(str_ret) + return ret + ret.append('--' + random.choice(PASSES)) + + counter = 0 + + while 1: + passes = pick_passes() + print('>>> [' + str(counter) + '] testing:', ' '.join(passes)) + counter += 1 + try: + apply_passes(passes) + except Exception as e: + print(e) + simplify(passes) + break + seen = run() + if seen != normal: + print('>>> bad output:\n', seen) + simplify(passes) + break + +finally: + if original_wast: + shutil.move(original_wast, wast) diff --git a/binaryen/scripts/fuzz_passes_wast.py b/binaryen/scripts/fuzz_passes_wast.py new file mode 100644 --- /dev/null +++ b/binaryen/scripts/fuzz_passes_wast.py @@ -0,0 +1,139 @@ +#!/usr/bin/env python3 +# +# Copyright 2016 WebAssembly Community Group participants +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +''' +This fuzzes passes, by starting with a wast, then running +random passes on the wast, and seeing if they break optimization +or validation + +Usage: Provide the filename of the wast. +''' + +from __future__ import print_function + +import os +import random +import shutil +import subprocess +import sys + +PASSES = [ + "duplicate-function-elimination", + "dce", + "remove-unused-brs", + "remove-unused-names", + "optimize-instructions", + "precompute", + "simplify-locals", + "vacuum", + "coalesce-locals", + "reorder-locals", + "merge-blocks", + "remove-unused-functions", +] + +# main + +wast = sys.argv[1] +print('>>> wast:', wast) + +args = sys.argv[2:] + + +def run(): + try: + cmd = ['bin/wasm-opt', wast] + print('run', cmd) + subprocess.check_call(cmd, stderr=open('/dev/null')) + except Exception as e: + return ">>> !!! ", e, " !!!" + return 'ok' + + +original_wast = None + +try: + # get normal output + + normal = run() + print('>>> normal output:\n', normal) + assert normal, 'must be output' + + # ensure we actually use the wast + + original_wast = wast + '.original.wast' + shutil.move(wast, original_wast) + + def apply_passes(passes): + wasm_opt = os.path.join('bin', 'wasm-opt') + subprocess.check_call([wasm_opt, original_wast] + passes + ['-o', wast], + stderr=open('/dev/null')) + + # loop, looking for failures + + def simplify(passes): + # passes is known to fail, try to simplify down by removing + more = True + while more: + more = False + print('>>> trying to reduce:', ' '.join(passes), ' [' + str(len(passes)) + ']') + for i in range(len(passes)): + smaller = passes[:i] + passes[i + 1:] + print('>>>>>> try to reduce to:', ' '.join(smaller), ' [' + str(len(smaller)) + ']') + try: + apply_passes(smaller) + assert run() == normal + except Exception: + # this failed too, so it's a good reduction + passes = smaller + print('>>> reduction successful') + more = True + break + print('>>> reduced to:', ' '.join(passes)) + + tested = set() + + def pick_passes(): + # return '--waka'.split(' ') + ret = [] + while 1: + str_ret = str(ret) + if random.random() < 0.5 and str_ret not in tested: + tested.add(str_ret) + return ret + ret.append('--' + random.choice(PASSES)) + + counter = 0 + + while 1: + passes = pick_passes() + print('>>> [' + str(counter) + '] testing:', ' '.join(passes)) + counter += 1 + try: + apply_passes(passes) + except Exception as e: + print(e) + simplify(passes) + break + seen = run() + if seen != normal: + print('>>> bad output:\n', seen) + simplify(passes) + break + +finally: + if original_wast: + shutil.move(original_wast, wast) diff --git a/binaryen/scripts/fuzz_relooper.py b/binaryen/scripts/fuzz_relooper.py new file mode 100644 --- /dev/null +++ b/binaryen/scripts/fuzz_relooper.py @@ -0,0 +1,389 @@ +#!/usr/bin/env python3 +# +# Copyright 2016 WebAssembly Community Group participants +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +''' +This fuzzes the relooper using the C API. +''' + +from __future__ import print_function + +import difflib +import os +import random +import subprocess +import time + +seed_init = int(time.time()) +seed_init *= seed_init +seed_init %= (2**32) + +if os.environ.get('LD_LIBRARY_PATH'): + os.environ['LD_LIBRARY_PATH'] += os.pathsep + 'lib' +else: + os.environ['LD_LIBRARY_PATH'] = 'lib' + +counter = 0 + +while True: + # Random decisions + seed = seed_init + random.seed(seed) + seed_init += 1 + num = random.randint(2, 250) + density = random.random() * random.random() + code_likelihood = random.random() + code_max = random.randint(0, num if random.random() < 0.5 else 3) + max_printed = random.randint(1, num if random.random() < 0.5 else 3) + max_decision = num * 20 + decisions = [random.randint(1, max_decision) for x in range(num * 3)] + branches = [0] * num + defaults = [0] * num + branch_codes = [0] * num # code on the branch, which may alter the global state + + # with some probability print the same id for different blocks, + # as the printing is the block contents - allow merging etc. opts + def printed_id(i): + if random.random() < 0.5: + return i + return i % max_printed + + printed_ids = [printed_id(i) for i in range(num)] + + def random_code(): + if code_max == 0 or random.random() > code_likelihood: + return 0 # no code + # A random number to perturb/increment the global state + return random.randint(1, code_max) + + for i in range(num): + b = set([]) + bs = random.randint(1, max(1, + round(density * random.random() * (num - 1)))) + for j in range(bs): + b.add(random.randint(1, num - 1)) + b = list(b) + defaults[i] = random.choice(b) + b.remove(defaults[i]) + branches[i] = b + branch_codes[i] = [random_code() for item in range(len(b) + 1)] # one for each branch, plus the default + optimize = random.random() < 0.5 + print(counter, ':', num, density, optimize, code_likelihood, code_max, max_printed, ', seed =', seed) + counter += 1 + + for temp in ['fuzz.wasm', 'fuzz.wast', 'fast.txt', 'fuzz.slow.js', + 'fuzz.c']: + try: + os.unlink(temp) + except OSError: + pass + + # parts + entry = ''' +var label = 0; +var state; +var decisions = %s; +var index = 0; +function check() { + if (index >= decisions.length) throw 'HALT'; + console.log('(i32.const ' + (-decisions[index]) + ')'); + return decisions[index++]; +} +''' % str(decisions) + + slow = entry + '\n' + slow += 'label = 0;\n' + + slow += ''' +while(1) switch(label) { +''' + + fast = ''' + +#include +#include + +#include "binaryen-c.h" + +// globals: address 4 is index +// decisions are at address 8+ + +int main() { + BinaryenModuleRef module = BinaryenModuleCreate(); + + // check() + + // if the end, halt + BinaryenExpressionRef halter = BinaryenIf(module, + BinaryenBinary(module, + BinaryenGeUInt32(), + BinaryenLoad(module, 4, 0, 0, 0, BinaryenTypeInt32(), + BinaryenConst(module, BinaryenLiteralInt32(4))), + BinaryenConst(module, BinaryenLiteralInt32(4 * %d)) // jumps of 4 bytes + ), + BinaryenUnreachable(module), + NULL + ); + // increment index + BinaryenExpressionRef incer = BinaryenStore(module, + 4, 0, 0, + BinaryenConst(module, BinaryenLiteralInt32(4)), + BinaryenBinary(module, + BinaryenAddInt32(), + BinaryenLoad(module, 4, 0, 0, 0, BinaryenTypeInt32(), + BinaryenConst(module, BinaryenLiteralInt32(4))), + BinaryenConst(module, BinaryenLiteralInt32(4)) + ), + BinaryenTypeInt32() + ); + + // optionally, print the return value + BinaryenExpressionRef args[] = { + BinaryenBinary(module, + BinaryenSubInt32(), + BinaryenConst(module, BinaryenLiteralInt32(0)), + BinaryenLoad(module, + 4, 0, 4, 0, BinaryenTypeInt32(), + BinaryenLoad(module, 4, 0, 0, 0, BinaryenTypeInt32(), + BinaryenConst(module, BinaryenLiteralInt32(4))) + ) + ) + }; + BinaryenExpressionRef debugger; + if (1) debugger = BinaryenCall(module, "print", args, 1, + BinaryenTypeNone()); + else debugger = BinaryenNop(module); + + // return the decision. need to subtract 4 that we just added, + // and add 8 since that's where we start, so overall offset 4 + BinaryenExpressionRef returner = BinaryenLoad(module, + 4, 0, 4, 0, BinaryenTypeInt32(), + BinaryenLoad(module, 4, 0, 0, 0, BinaryenTypeInt32(), + BinaryenConst(module, BinaryenLiteralInt32(4))) + ); + BinaryenExpressionRef checkBodyList[] = { halter, incer, debugger, + returner }; + BinaryenExpressionRef checkBody = BinaryenBlock(module, + NULL, checkBodyList, sizeof(checkBodyList) / sizeof(BinaryenExpressionRef), + BinaryenTypeInt32() + ); + BinaryenFunctionTypeRef i = BinaryenAddFunctionType(module, "i", + BinaryenTypeInt32(), + NULL, 0); + BinaryenAddFunction(module, "check", i, NULL, 0, checkBody); + + // contents of main() begin here + + RelooperRef relooper = RelooperCreate(module); + +''' % len(decisions) + + for i in range(num): + slow += ' case %d: console.log("(i32.const %d)"); state = check(); \n' % ( + i, printed_ids[i]) + b = branches[i] + bc = branch_codes[i] + + def get_phi(j): + phi = '' + if bc[j]: + phi = 'index += %d; ' % bc[j] + return phi + + for j in range(len(b)): + slow += ' if (state %% %d == %d) { %s label = %d; break }\n' % ( + len(b) + 1, j, get_phi(j), b[j]) # TODO: split range 1-n into these options + slow += ' %slabel = %d; break\n' % (get_phi(-1), defaults[i]) + + use_switch = [random.random() < 0.5 for i in range(num)] + + for i in range(num): + fast += ''' + RelooperBlockRef b%d; + { + BinaryenExpressionRef args[] = { + BinaryenConst(module, BinaryenLiteralInt32(%d)) + }; + BinaryenExpressionRef list[] = { + BinaryenCall(module, "print", args, 1, BinaryenTypeNone()), + BinaryenLocalSet(module, 0, BinaryenCall(module, "check", NULL, 0, + BinaryenTypeInt32())) + }; +''' % (i, printed_ids[i]) + if use_switch[i]: + fast += ''' + b%d = RelooperAddBlockWithSwitch(relooper, + BinaryenBlock(module, NULL, list, 2, BinaryenTypeNone()), + BinaryenBinary(module, + BinaryenRemUInt32(), + BinaryenLocalGet(module, 0, BinaryenTypeInt32()), + BinaryenConst(module, BinaryenLiteralInt32(%d)) + ) + ); +''' % (i, len(branches[i]) + 1) + else: # non-switch + fast += ''' + b%d = RelooperAddBlock(relooper, BinaryenBlock(module, NULL, list, 2, BinaryenTypeNone())); +''' % i + fast += ''' + } +''' + + for i in range(num): + b = branches[i] + bc = branch_codes[i] + + def get_phi(j): + phi = 'NULL' + if bc[j]: + # increment the index of global state + phi = ''' + BinaryenStore(module, + 4, 0, 0, + BinaryenConst(module, BinaryenLiteralInt32(4)), + BinaryenBinary(module, + BinaryenAddInt32(), + BinaryenLoad(module, 4, 0, 0, 0, BinaryenTypeInt32(), + BinaryenConst(module, BinaryenLiteralInt32(4))), + BinaryenConst(module, BinaryenLiteralInt32(4 * %d)) + ), + BinaryenTypeInt32() + )''' % bc[j] + return phi + + for j in range(len(b)): + if use_switch[i]: + total = len(b) + 1 + values = ','.join([str(x) for x in range(random.randint(len(b) + 1, + max_decision + 2)) if x % total == j]) + fast += ''' + { + BinaryenIndex values[] = { %s }; + RelooperAddBranchForSwitch(b%d, b%d, values, + sizeof(values) / sizeof(BinaryenIndex), %s); + } +''' % (values, i, b[j], get_phi(j)) + else: # non-switch + fast += ''' + RelooperAddBranch(b%d, b%d, BinaryenBinary(module, + BinaryenEqInt32(), + BinaryenBinary(module, + BinaryenRemUInt32(), + BinaryenLocalGet(module, 0, BinaryenTypeInt32()), + BinaryenConst(module, BinaryenLiteralInt32(%d)) + ), + BinaryenConst(module, BinaryenLiteralInt32(%d)) + ), %s); +''' % (i, b[j], len(b) + 1, j, get_phi(j)) + # default branch + if use_switch[i]: + fast += ''' + RelooperAddBranchForSwitch(b%d, b%d, NULL, 0, %s); +''' % (i, defaults[i], get_phi(-1)) + else: + fast += ''' + RelooperAddBranch(b%d, b%d, NULL, %s); +''' % (i, defaults[i], get_phi(-1)) + + fast += ''' + BinaryenExpressionRef body = RelooperRenderAndDispose(relooper, b0, 1); + + int decisions[] = { %s }; + int numDecisions = sizeof(decisions)/sizeof(int); + + // write out all the decisions, then the body of the function + BinaryenExpressionRef full[numDecisions + 1]; + + { + int i; + for (i = 0; i < numDecisions; i++) { + full[i] = BinaryenStore(module, + 4, 0, 0, + BinaryenConst(module, BinaryenLiteralInt32(8 + 4 * i)), + BinaryenConst(module, BinaryenLiteralInt32(decisions[i])), + BinaryenTypeInt32() + ); + } + } + full[numDecisions] = body; + BinaryenExpressionRef all = BinaryenBlock(module, NULL, full, + numDecisions + 1, + BinaryenTypeNone()); + + BinaryenFunctionTypeRef v = BinaryenAddFunctionType(module, "v", + BinaryenTypeNone(), + NULL, 0); + // locals: state, free-for-label + BinaryenType localTypes[] = { BinaryenTypeInt32(), BinaryenTypeInt32() }; + BinaryenFunctionRef theMain = BinaryenAddFunction(module, "main", v, + localTypes, 2, all); + BinaryenSetStart(module, theMain); + + // import + + BinaryenType iparams[] = { BinaryenTypeInt32() }; + BinaryenFunctionTypeRef vi = BinaryenAddFunctionType(module, "vi", + BinaryenTypeNone(), + iparams, 1); + BinaryenAddFunctionImport(module, "print", "spectest", "print", vi); + + // memory + BinaryenSetMemory(module, 1, 1, "mem", NULL, NULL, NULL, 0, 0); + + // optionally, optimize + if (%d) BinaryenModuleOptimize(module); + + assert(BinaryenModuleValidate(module)); + + // write it out + + BinaryenModulePrint(module); + + BinaryenModuleDispose(module); + + return 0; +} +''' % (', '.join(map(str, decisions)), optimize) + + slow += '}' + + open('fuzz.slow.js', 'w').write(slow) + open('fuzz.c', 'w').write(fast) + + print('.') + cmd = [os.environ.get('CC') or 'gcc', 'fuzz.c', '-Isrc', + '-lbinaryen', '-lasmjs', + '-lsupport', '-Llib/.', '-pthread', '-o', 'fuzz'] + subprocess.check_call(cmd) + print('^') + subprocess.check_call(['./fuzz'], stdout=open('fuzz.wast', 'w')) + print('*') + fast_out = subprocess.Popen(['bin/wasm-shell', 'fuzz.wast'], + stdout=subprocess.PIPE, + stderr=subprocess.PIPE).communicate()[0] + print('-') + node = os.getenv('NODE', 'nodejs') + slow_out = subprocess.Popen([node, 'fuzz.slow.js'], + stdout=subprocess.PIPE, + stderr=subprocess.PIPE).communicate()[0] + print('_') + + if slow_out != fast_out: + print(''.join([a.rstrip() + '\n' for a in difflib.unified_diff( + slow_out.split('\n'), + fast_out.split('\n'), + fromfile='slow', + tofile='fast')])) + assert False diff --git a/binaryen/scripts/fuzz_shell.js b/binaryen/scripts/fuzz_shell.js new file mode 100644 --- /dev/null +++ b/binaryen/scripts/fuzz_shell.js @@ -0,0 +1,219 @@ +// Shell integration. +if (typeof console === 'undefined') { + console = { log: print }; +} +var tempRet0; +var binary; +if (typeof process === 'object' && typeof require === 'function' /* node.js detection */) { + var args = process.argv.slice(2); + binary = require('fs').readFileSync(args[0]); + if (!binary.buffer) binary = new Uint8Array(binary); +} else { + var args; + if (typeof scriptArgs != 'undefined') { + args = scriptArgs; + } else if (typeof arguments != 'undefined') { + args = arguments; + } + if (typeof readbuffer === 'function') { + binary = new Uint8Array(readbuffer(args[0])); + } else { + binary = read(args[0], 'binary'); + } +} + +// Utilities. +function assert(x, y) { + if (!x) throw (y || 'assertion failed');// + new Error().stack; +} + +// Deterministic randomness. +var detrand = (function() { + var hash = 5381; // TODO DET_RAND_SEED; + var x = 0; + return function() { + hash = (((hash << 5) + hash) ^ (x & 0xff)) >>> 0; + x = (x + 1) % 256; + return (hash % 256) / 256; + }; +})(); + +// Asyncify integration. +var Asyncify = { + sleeping: false, + sleepingFunction: null, + sleeps: 0, + maxDepth: 0, + DATA_ADDR: 4, + DATA_MAX: 65536, + savedMemory: null, + instrumentImports: function(imports) { + var ret = {}; + for (var module in imports) { + ret[module] = {}; + for (var i in imports[module]) { + if (typeof imports[module][i] === 'function') { + (function(module, i) { + ret[module][i] = function() { + refreshView(); + if (!Asyncify.sleeping) { + // Sleep if asyncify support is present (which also requires + // that the memory be exported), and at a certain probability. + if (exports.asyncify_start_unwind && + view && + detrand() < 0.5) { + // We are called in order to start a sleep/unwind. + console.log('asyncify: sleep in ' + i + '...'); + Asyncify.sleepingFunction = i; + Asyncify.sleeps++; + var depth = new Error().stack.split('\n').length - 6; + Asyncify.maxDepth = Math.max(Asyncify.maxDepth, depth); + // Save the memory we use for data, so after we restore it later, the + // sleep/resume appears to have had no change to memory. + Asyncify.savedMemory = new Int32Array(view.subarray(Asyncify.DATA_ADDR >> 2, Asyncify.DATA_MAX >> 2)); + // Unwinding. + // Fill in the data structure. The first value has the stack location, + // which for simplicity we can start right after the data structure itself. + view[Asyncify.DATA_ADDR >> 2] = Asyncify.DATA_ADDR + 8; + // The end of the stack will not be reached here anyhow. + view[Asyncify.DATA_ADDR + 4 >> 2] = Asyncify.DATA_MAX; + exports.asyncify_start_unwind(Asyncify.DATA_ADDR); + Asyncify.sleeping = true; + } else { + // Don't sleep, normal execution. + return imports[module][i].apply(null, arguments); + } + } else { + // We are called as part of a resume/rewind. Stop sleeping. + console.log('asyncify: resume in ' + i + '...'); + assert(Asyncify.sleepingFunction === i); + exports.asyncify_stop_rewind(); + // The stack should have been all used up, and so returned to the original state. + assert(view[Asyncify.DATA_ADDR >> 2] == Asyncify.DATA_ADDR + 8); + assert(view[Asyncify.DATA_ADDR + 4 >> 2] == Asyncify.DATA_MAX); + Asyncify.sleeping = false; + // Restore the memory to the state from before we slept. + view.set(Asyncify.savedMemory, Asyncify.DATA_ADDR >> 2); + return imports[module][i].apply(null, arguments); + } + }; + })(module, i); + } else { + ret[module][i] = imports[module][i]; + } + } + } + // Add ignored.print, which is ignored by asyncify, and allows debugging of asyncified code. + ret['ignored'] = { 'print': function(x, y) { console.log(x, y) } }; + return ret; + }, + instrumentExports: function(exports) { + var ret = {}; + for (var e in exports) { + if (typeof exports[e] === 'function' && + !e.startsWith('asyncify_')) { + (function(e) { + ret[e] = function() { + while (1) { + var ret = exports[e].apply(null, arguments); + // If we are sleeping, then the stack was unwound; rewind it. + if (Asyncify.sleeping) { + console.log('asyncify: stop unwind; rewind'); + assert(!ret, 'results during sleep are meaningless, just 0'); + //console.log('asyncify: after unwind', view[Asyncify.DATA_ADDR >> 2], view[Asyncify.DATA_ADDR + 4 >> 2]); + try { + exports.asyncify_stop_unwind(); + exports.asyncify_start_rewind(Asyncify.DATA_ADDR); + } catch (e) { + console.log('error in unwind/rewind switch', e); + } + continue; + } + return ret; + } + }; + })(e); + } else { + ret[e] = exports[e]; + } + } + return ret; + }, + check: function() { + assert(!Asyncify.sleeping); + }, + finish: function() { + if (Asyncify.sleeps > 0) { + print('asyncify:', 'sleeps:', Asyncify.sleeps, 'max depth:', Asyncify.maxDepth); + } + }, +}; + +// Fuzz integration. +function logValue(x, y) { + if (typeof y !== 'undefined') { + console.log('[LoggingExternalInterface logging ' + x + ' ' + y + ']'); + } else { + console.log('[LoggingExternalInterface logging ' + x + ']'); + } +} + +// Set up the imports. +var imports = { + 'fuzzing-support': { + 'log-i32': logValue, + 'log-i64': logValue, + 'log-f32': logValue, + 'log-f64': logValue, + }, + 'env': { + 'setTempRet0': function(x) { tempRet0 = x }, + 'getTempRet0': function() { return tempRet0 }, + }, +}; + +imports = Asyncify.instrumentImports(imports); + +// Create the wasm. +var instance = new WebAssembly.Instance(new WebAssembly.Module(binary), imports); + +// Handle the exports. +var exports = instance.exports; +exports = Asyncify.instrumentExports(exports); + +var view; + +// Recreate the view. This is important both initially and after a growth. +function refreshView() { + if (exports.memory) { + view = new Int32Array(exports.memory.buffer); + } +} + +// Run the wasm. +var sortedExports = []; +for (var e in exports) { + sortedExports.push(e); +} +sortedExports.sort(); +sortedExports = sortedExports.filter(function(e) { + // Filter special intrinsic functions. + return !e.startsWith('asyncify_'); +}); +sortedExports.forEach(function(e) { + Asyncify.check(); + if (typeof exports[e] !== 'function') return; + try { + console.log('[fuzz-exec] calling ' + e); + var result = exports[e](); + if (typeof result !== 'undefined') { + console.log('[fuzz-exec] note result: $' + e + ' => ' + result); + } + } catch (e) { + console.log('exception!');// + [e, e.stack]); + } +}); + +// Finish up +Asyncify.finish(); + diff --git a/binaryen/scripts/gen-s-parser.py b/binaryen/scripts/gen-s-parser.py new file mode 100644 --- /dev/null +++ b/binaryen/scripts/gen-s-parser.py @@ -0,0 +1,665 @@ +#!/usr/bin/env python3 +# +# Copyright 2018 WebAssembly Community Group participants +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import sys + +instructions = [ + ("unreachable", "makeUnreachable()"), + ("nop", "makeNop()"), + ("block", "makeBlock(s)"), + ("loop", "makeLoop(s)"), + ("if", "makeIf(s)"), + ("then", "makeThenOrElse(s)"), + ("else", "makeThenOrElse(s)"), + ("br", "makeBreak(s)"), + ("br_if", "makeBreak(s)"), + ("br_table", "makeBreakTable(s)"), + ("return", "makeReturn(s)"), + ("call", "makeCall(s, /*isReturn=*/false)"), + ("call_indirect", "makeCallIndirect(s, /*isReturn=*/false)"), + ("return_call", "makeCall(s, /*isReturn=*/true)"), + ("return_call_indirect", "makeCallIndirect(s, /*isReturn=*/true)"), + ("drop", "makeDrop(s)"), + ("select", "makeSelect(s)"), + ("local.get", "makeLocalGet(s)"), + ("local.set", "makeLocalSet(s)"), + ("local.tee", "makeLocalTee(s)"), + ("global.get", "makeGlobalGet(s)"), + ("global.set", "makeGlobalSet(s)"), + ("memory.init", "makeMemoryInit(s)"), + ("data.drop", "makeDataDrop(s)"), + ("memory.copy", "makeMemoryCopy(s)"), + ("memory.fill", "makeMemoryFill(s)"), + ("i32.load", "makeLoad(s, Type::i32, /*isAtomic=*/false)"), + ("i64.load", "makeLoad(s, Type::i64, /*isAtomic=*/false)"), + ("f32.load", "makeLoad(s, Type::f32, /*isAtomic=*/false)"), + ("f64.load", "makeLoad(s, Type::f64, /*isAtomic=*/false)"), + ("i32.load8_s", "makeLoad(s, Type::i32, /*isAtomic=*/false)"), + ("i32.load8_u", "makeLoad(s, Type::i32, /*isAtomic=*/false)"), + ("i32.load16_s", "makeLoad(s, Type::i32, /*isAtomic=*/false)"), + ("i32.load16_u", "makeLoad(s, Type::i32, /*isAtomic=*/false)"), + ("i64.load8_s", "makeLoad(s, Type::i64, /*isAtomic=*/false)"), + ("i64.load8_u", "makeLoad(s, Type::i64, /*isAtomic=*/false)"), + ("i64.load16_s", "makeLoad(s, Type::i64, /*isAtomic=*/false)"), + ("i64.load16_u", "makeLoad(s, Type::i64, /*isAtomic=*/false)"), + ("i64.load32_s", "makeLoad(s, Type::i64, /*isAtomic=*/false)"), + ("i64.load32_u", "makeLoad(s, Type::i64, /*isAtomic=*/false)"), + ("i32.store", "makeStore(s, Type::i32, /*isAtomic=*/false)"), + ("i64.store", "makeStore(s, Type::i64, /*isAtomic=*/false)"), + ("f32.store", "makeStore(s, Type::f32, /*isAtomic=*/false)"), + ("f64.store", "makeStore(s, Type::f64, /*isAtomic=*/false)"), + ("i32.store8", "makeStore(s, Type::i32, /*isAtomic=*/false)"), + ("i32.store16", "makeStore(s, Type::i32, /*isAtomic=*/false)"), + ("i64.store8", "makeStore(s, Type::i64, /*isAtomic=*/false)"), + ("i64.store16", "makeStore(s, Type::i64, /*isAtomic=*/false)"), + ("i64.store32", "makeStore(s, Type::i64, /*isAtomic=*/false)"), + ("memory.size", "makeMemorySize(s)"), + ("memory.grow", "makeMemoryGrow(s)"), + ("i32.const", "makeConst(s, Type::i32)"), + ("i64.const", "makeConst(s, Type::i64)"), + ("f32.const", "makeConst(s, Type::f32)"), + ("f64.const", "makeConst(s, Type::f64)"), + ("i32.eqz", "makeUnary(s, UnaryOp::EqZInt32)"), + ("i32.eq", "makeBinary(s, BinaryOp::EqInt32)"), + ("i32.ne", "makeBinary(s, BinaryOp::NeInt32)"), + ("i32.lt_s", "makeBinary(s, BinaryOp::LtSInt32)"), + ("i32.lt_u", "makeBinary(s, BinaryOp::LtUInt32)"), + ("i32.gt_s", "makeBinary(s, BinaryOp::GtSInt32)"), + ("i32.gt_u", "makeBinary(s, BinaryOp::GtUInt32)"), + ("i32.le_s", "makeBinary(s, BinaryOp::LeSInt32)"), + ("i32.le_u", "makeBinary(s, BinaryOp::LeUInt32)"), + ("i32.ge_s", "makeBinary(s, BinaryOp::GeSInt32)"), + ("i32.ge_u", "makeBinary(s, BinaryOp::GeUInt32)"), + ("i64.eqz", "makeUnary(s, UnaryOp::EqZInt64)"), + ("i64.eq", "makeBinary(s, BinaryOp::EqInt64)"), + ("i64.ne", "makeBinary(s, BinaryOp::NeInt64)"), + ("i64.lt_s", "makeBinary(s, BinaryOp::LtSInt64)"), + ("i64.lt_u", "makeBinary(s, BinaryOp::LtUInt64)"), + ("i64.gt_s", "makeBinary(s, BinaryOp::GtSInt64)"), + ("i64.gt_u", "makeBinary(s, BinaryOp::GtUInt64)"), + ("i64.le_s", "makeBinary(s, BinaryOp::LeSInt64)"), + ("i64.le_u", "makeBinary(s, BinaryOp::LeUInt64)"), + ("i64.ge_s", "makeBinary(s, BinaryOp::GeSInt64)"), + ("i64.ge_u", "makeBinary(s, BinaryOp::GeUInt64)"), + ("f32.eq", "makeBinary(s, BinaryOp::EqFloat32)"), + ("f32.ne", "makeBinary(s, BinaryOp::NeFloat32)"), + ("f32.lt", "makeBinary(s, BinaryOp::LtFloat32)"), + ("f32.gt", "makeBinary(s, BinaryOp::GtFloat32)"), + ("f32.le", "makeBinary(s, BinaryOp::LeFloat32)"), + ("f32.ge", "makeBinary(s, BinaryOp::GeFloat32)"), + ("f64.eq", "makeBinary(s, BinaryOp::EqFloat64)"), + ("f64.ne", "makeBinary(s, BinaryOp::NeFloat64)"), + ("f64.lt", "makeBinary(s, BinaryOp::LtFloat64)"), + ("f64.gt", "makeBinary(s, BinaryOp::GtFloat64)"), + ("f64.le", "makeBinary(s, BinaryOp::LeFloat64)"), + ("f64.ge", "makeBinary(s, BinaryOp::GeFloat64)"), + ("i32.clz", "makeUnary(s, UnaryOp::ClzInt32)"), + ("i32.ctz", "makeUnary(s, UnaryOp::CtzInt32)"), + ("i32.popcnt", "makeUnary(s, UnaryOp::PopcntInt32)"), + ("i32.add", "makeBinary(s, BinaryOp::AddInt32)"), + ("i32.sub", "makeBinary(s, BinaryOp::SubInt32)"), + ("i32.mul", "makeBinary(s, BinaryOp::MulInt32)"), + ("i32.div_s", "makeBinary(s, BinaryOp::DivSInt32)"), + ("i32.div_u", "makeBinary(s, BinaryOp::DivUInt32)"), + ("i32.rem_s", "makeBinary(s, BinaryOp::RemSInt32)"), + ("i32.rem_u", "makeBinary(s, BinaryOp::RemUInt32)"), + ("i32.and", "makeBinary(s, BinaryOp::AndInt32)"), + ("i32.or", "makeBinary(s, BinaryOp::OrInt32)"), + ("i32.xor", "makeBinary(s, BinaryOp::XorInt32)"), + ("i32.shl", "makeBinary(s, BinaryOp::ShlInt32)"), + ("i32.shr_s", "makeBinary(s, BinaryOp::ShrSInt32)"), + ("i32.shr_u", "makeBinary(s, BinaryOp::ShrUInt32)"), + ("i32.rotl", "makeBinary(s, BinaryOp::RotLInt32)"), + ("i32.rotr", "makeBinary(s, BinaryOp::RotRInt32)"), + ("i64.clz", "makeUnary(s, UnaryOp::ClzInt64)"), + ("i64.ctz", "makeUnary(s, UnaryOp::CtzInt64)"), + ("i64.popcnt", "makeUnary(s, UnaryOp::PopcntInt64)"), + ("i64.add", "makeBinary(s, BinaryOp::AddInt64)"), + ("i64.sub", "makeBinary(s, BinaryOp::SubInt64)"), + ("i64.mul", "makeBinary(s, BinaryOp::MulInt64)"), + ("i64.div_s", "makeBinary(s, BinaryOp::DivSInt64)"), + ("i64.div_u", "makeBinary(s, BinaryOp::DivUInt64)"), + ("i64.rem_s", "makeBinary(s, BinaryOp::RemSInt64)"), + ("i64.rem_u", "makeBinary(s, BinaryOp::RemUInt64)"), + ("i64.and", "makeBinary(s, BinaryOp::AndInt64)"), + ("i64.or", "makeBinary(s, BinaryOp::OrInt64)"), + ("i64.xor", "makeBinary(s, BinaryOp::XorInt64)"), + ("i64.shl", "makeBinary(s, BinaryOp::ShlInt64)"), + ("i64.shr_s", "makeBinary(s, BinaryOp::ShrSInt64)"), + ("i64.shr_u", "makeBinary(s, BinaryOp::ShrUInt64)"), + ("i64.rotl", "makeBinary(s, BinaryOp::RotLInt64)"), + ("i64.rotr", "makeBinary(s, BinaryOp::RotRInt64)"), + ("f32.abs", "makeUnary(s, UnaryOp::AbsFloat32)"), + ("f32.neg", "makeUnary(s, UnaryOp::NegFloat32)"), + ("f32.ceil", "makeUnary(s, UnaryOp::CeilFloat32)"), + ("f32.floor", "makeUnary(s, UnaryOp::FloorFloat32)"), + ("f32.trunc", "makeUnary(s, UnaryOp::TruncFloat32)"), + ("f32.nearest", "makeUnary(s, UnaryOp::NearestFloat32)"), + ("f32.sqrt", "makeUnary(s, UnaryOp::SqrtFloat32)"), + ("f32.add", "makeBinary(s, BinaryOp::AddFloat32)"), + ("f32.sub", "makeBinary(s, BinaryOp::SubFloat32)"), + ("f32.mul", "makeBinary(s, BinaryOp::MulFloat32)"), + ("f32.div", "makeBinary(s, BinaryOp::DivFloat32)"), + ("f32.min", "makeBinary(s, BinaryOp::MinFloat32)"), + ("f32.max", "makeBinary(s, BinaryOp::MaxFloat32)"), + ("f32.copysign", "makeBinary(s, BinaryOp::CopySignFloat32)"), + ("f64.abs", "makeUnary(s, UnaryOp::AbsFloat64)"), + ("f64.neg", "makeUnary(s, UnaryOp::NegFloat64)"), + ("f64.ceil", "makeUnary(s, UnaryOp::CeilFloat64)"), + ("f64.floor", "makeUnary(s, UnaryOp::FloorFloat64)"), + ("f64.trunc", "makeUnary(s, UnaryOp::TruncFloat64)"), + ("f64.nearest", "makeUnary(s, UnaryOp::NearestFloat64)"), + ("f64.sqrt", "makeUnary(s, UnaryOp::SqrtFloat64)"), + ("f64.add", "makeBinary(s, BinaryOp::AddFloat64)"), + ("f64.sub", "makeBinary(s, BinaryOp::SubFloat64)"), + ("f64.mul", "makeBinary(s, BinaryOp::MulFloat64)"), + ("f64.div", "makeBinary(s, BinaryOp::DivFloat64)"), + ("f64.min", "makeBinary(s, BinaryOp::MinFloat64)"), + ("f64.max", "makeBinary(s, BinaryOp::MaxFloat64)"), + ("f64.copysign", "makeBinary(s, BinaryOp::CopySignFloat64)"), + ("i32.wrap_i64", "makeUnary(s, UnaryOp::WrapInt64)"), + ("i32.trunc_f32_s", "makeUnary(s, UnaryOp::TruncSFloat32ToInt32)"), + ("i32.trunc_f32_u", "makeUnary(s, UnaryOp::TruncUFloat32ToInt32)"), + ("i32.trunc_f64_s", "makeUnary(s, UnaryOp::TruncSFloat64ToInt32)"), + ("i32.trunc_f64_u", "makeUnary(s, UnaryOp::TruncUFloat64ToInt32)"), + ("i64.extend_i32_s", "makeUnary(s, UnaryOp::ExtendSInt32)"), + ("i64.extend_i32_u", "makeUnary(s, UnaryOp::ExtendUInt32)"), + ("i64.trunc_f32_s", "makeUnary(s, UnaryOp::TruncSFloat32ToInt64)"), + ("i64.trunc_f32_u", "makeUnary(s, UnaryOp::TruncUFloat32ToInt64)"), + ("i64.trunc_f64_s", "makeUnary(s, UnaryOp::TruncSFloat64ToInt64)"), + ("i64.trunc_f64_u", "makeUnary(s, UnaryOp::TruncUFloat64ToInt64)"), + ("f32.convert_i32_s", "makeUnary(s, UnaryOp::ConvertSInt32ToFloat32)"), + ("f32.convert_i32_u", "makeUnary(s, UnaryOp::ConvertUInt32ToFloat32)"), + ("f32.convert_i64_s", "makeUnary(s, UnaryOp::ConvertSInt64ToFloat32)"), + ("f32.convert_i64_u", "makeUnary(s, UnaryOp::ConvertUInt64ToFloat32)"), + ("f32.demote_f64", "makeUnary(s, UnaryOp::DemoteFloat64)"), + ("f64.convert_i32_s", "makeUnary(s, UnaryOp::ConvertSInt32ToFloat64)"), + ("f64.convert_i32_u", "makeUnary(s, UnaryOp::ConvertUInt32ToFloat64)"), + ("f64.convert_i64_s", "makeUnary(s, UnaryOp::ConvertSInt64ToFloat64)"), + ("f64.convert_i64_u", "makeUnary(s, UnaryOp::ConvertUInt64ToFloat64)"), + ("f64.promote_f32", "makeUnary(s, UnaryOp::PromoteFloat32)"), + ("i32.reinterpret_f32", "makeUnary(s, UnaryOp::ReinterpretFloat32)"), + ("i64.reinterpret_f64", "makeUnary(s, UnaryOp::ReinterpretFloat64)"), + ("f32.reinterpret_i32", "makeUnary(s, UnaryOp::ReinterpretInt32)"), + ("f64.reinterpret_i64", "makeUnary(s, UnaryOp::ReinterpretInt64)"), + ("i32.extend8_s", "makeUnary(s, UnaryOp::ExtendS8Int32)"), + ("i32.extend16_s", "makeUnary(s, UnaryOp::ExtendS16Int32)"), + ("i64.extend8_s", "makeUnary(s, UnaryOp::ExtendS8Int64)"), + ("i64.extend16_s", "makeUnary(s, UnaryOp::ExtendS16Int64)"), + ("i64.extend32_s", "makeUnary(s, UnaryOp::ExtendS32Int64)"), + # atomic instructions + ("atomic.notify", "makeAtomicNotify(s)"), + ("i32.atomic.wait", "makeAtomicWait(s, Type::i32)"), + ("i64.atomic.wait", "makeAtomicWait(s, Type::i64)"), + ("atomic.fence", "makeAtomicFence(s)"), + ("i32.atomic.load8_u", "makeLoad(s, Type::i32, /*isAtomic=*/true)"), + ("i32.atomic.load16_u", "makeLoad(s, Type::i32, /*isAtomic=*/true)"), + ("i32.atomic.load", "makeLoad(s, Type::i32, /*isAtomic=*/true)"), + ("i64.atomic.load8_u", "makeLoad(s, Type::i64, /*isAtomic=*/true)"), + ("i64.atomic.load16_u", "makeLoad(s, Type::i64, /*isAtomic=*/true)"), + ("i64.atomic.load32_u", "makeLoad(s, Type::i64, /*isAtomic=*/true)"), + ("i64.atomic.load", "makeLoad(s, Type::i64, /*isAtomic=*/true)"), + ("i32.atomic.store8", "makeStore(s, Type::i32, /*isAtomic=*/true)"), + ("i32.atomic.store16", "makeStore(s, Type::i32, /*isAtomic=*/true)"), + ("i32.atomic.store", "makeStore(s, Type::i32, /*isAtomic=*/true)"), + ("i64.atomic.store8", "makeStore(s, Type::i64, /*isAtomic=*/true)"), + ("i64.atomic.store16", "makeStore(s, Type::i64, /*isAtomic=*/true)"), + ("i64.atomic.store32", "makeStore(s, Type::i64, /*isAtomic=*/true)"), + ("i64.atomic.store", "makeStore(s, Type::i64, /*isAtomic=*/true)"), + ("i32.atomic.rmw8.add_u", "makeAtomicRMWOrCmpxchg(s, Type::i32)"), + ("i32.atomic.rmw16.add_u", "makeAtomicRMWOrCmpxchg(s, Type::i32)"), + ("i32.atomic.rmw.add", "makeAtomicRMWOrCmpxchg(s, Type::i32)"), + ("i64.atomic.rmw8.add_u", "makeAtomicRMWOrCmpxchg(s, Type::i64)"), + ("i64.atomic.rmw16.add_u", "makeAtomicRMWOrCmpxchg(s, Type::i64)"), + ("i64.atomic.rmw32.add_u", "makeAtomicRMWOrCmpxchg(s, Type::i64)"), + ("i64.atomic.rmw.add", "makeAtomicRMWOrCmpxchg(s, Type::i64)"), + ("i32.atomic.rmw8.sub_u", "makeAtomicRMWOrCmpxchg(s, Type::i32)"), + ("i32.atomic.rmw16.sub_u", "makeAtomicRMWOrCmpxchg(s, Type::i32)"), + ("i32.atomic.rmw.sub", "makeAtomicRMWOrCmpxchg(s, Type::i32)"), + ("i64.atomic.rmw8.sub_u", "makeAtomicRMWOrCmpxchg(s, Type::i64)"), + ("i64.atomic.rmw16.sub_u", "makeAtomicRMWOrCmpxchg(s, Type::i64)"), + ("i64.atomic.rmw32.sub_u", "makeAtomicRMWOrCmpxchg(s, Type::i64)"), + ("i64.atomic.rmw.sub", "makeAtomicRMWOrCmpxchg(s, Type::i64)"), + ("i32.atomic.rmw8.and_u", "makeAtomicRMWOrCmpxchg(s, Type::i32)"), + ("i32.atomic.rmw16.and_u", "makeAtomicRMWOrCmpxchg(s, Type::i32)"), + ("i32.atomic.rmw.and", "makeAtomicRMWOrCmpxchg(s, Type::i32)"), + ("i64.atomic.rmw8.and_u", "makeAtomicRMWOrCmpxchg(s, Type::i64)"), + ("i64.atomic.rmw16.and_u", "makeAtomicRMWOrCmpxchg(s, Type::i64)"), + ("i64.atomic.rmw32.and_u", "makeAtomicRMWOrCmpxchg(s, Type::i64)"), + ("i64.atomic.rmw.and", "makeAtomicRMWOrCmpxchg(s, Type::i64)"), + ("i32.atomic.rmw8.or_u", "makeAtomicRMWOrCmpxchg(s, Type::i32)"), + ("i32.atomic.rmw16.or_u", "makeAtomicRMWOrCmpxchg(s, Type::i32)"), + ("i32.atomic.rmw.or", "makeAtomicRMWOrCmpxchg(s, Type::i32)"), + ("i64.atomic.rmw8.or_u", "makeAtomicRMWOrCmpxchg(s, Type::i64)"), + ("i64.atomic.rmw16.or_u", "makeAtomicRMWOrCmpxchg(s, Type::i64)"), + ("i64.atomic.rmw32.or_u", "makeAtomicRMWOrCmpxchg(s, Type::i64)"), + ("i64.atomic.rmw.or", "makeAtomicRMWOrCmpxchg(s, Type::i64)"), + ("i32.atomic.rmw8.xor_u", "makeAtomicRMWOrCmpxchg(s, Type::i32)"), + ("i32.atomic.rmw16.xor_u", "makeAtomicRMWOrCmpxchg(s, Type::i32)"), + ("i32.atomic.rmw.xor", "makeAtomicRMWOrCmpxchg(s, Type::i32)"), + ("i64.atomic.rmw8.xor_u", "makeAtomicRMWOrCmpxchg(s, Type::i64)"), + ("i64.atomic.rmw16.xor_u", "makeAtomicRMWOrCmpxchg(s, Type::i64)"), + ("i64.atomic.rmw32.xor_u", "makeAtomicRMWOrCmpxchg(s, Type::i64)"), + ("i64.atomic.rmw.xor", "makeAtomicRMWOrCmpxchg(s, Type::i64)"), + ("i32.atomic.rmw8.xchg_u", "makeAtomicRMWOrCmpxchg(s, Type::i32)"), + ("i32.atomic.rmw16.xchg_u", "makeAtomicRMWOrCmpxchg(s, Type::i32)"), + ("i32.atomic.rmw.xchg", "makeAtomicRMWOrCmpxchg(s, Type::i32)"), + ("i64.atomic.rmw8.xchg_u", "makeAtomicRMWOrCmpxchg(s, Type::i64)"), + ("i64.atomic.rmw16.xchg_u", "makeAtomicRMWOrCmpxchg(s, Type::i64)"), + ("i64.atomic.rmw32.xchg_u", "makeAtomicRMWOrCmpxchg(s, Type::i64)"), + ("i64.atomic.rmw.xchg", "makeAtomicRMWOrCmpxchg(s, Type::i64)"), + ("i32.atomic.rmw8.cmpxchg_u", "makeAtomicRMWOrCmpxchg(s, Type::i32)"), + ("i32.atomic.rmw16.cmpxchg_u", "makeAtomicRMWOrCmpxchg(s, Type::i32)"), + ("i32.atomic.rmw.cmpxchg", "makeAtomicRMWOrCmpxchg(s, Type::i32)"), + ("i64.atomic.rmw8.cmpxchg_u", "makeAtomicRMWOrCmpxchg(s, Type::i64)"), + ("i64.atomic.rmw16.cmpxchg_u", "makeAtomicRMWOrCmpxchg(s, Type::i64)"), + ("i64.atomic.rmw32.cmpxchg_u", "makeAtomicRMWOrCmpxchg(s, Type::i64)"), + ("i64.atomic.rmw.cmpxchg", "makeAtomicRMWOrCmpxchg(s, Type::i64)"), + # nontrapping float-to-int instructions + ("i32.trunc_sat_f32_s", "makeUnary(s, UnaryOp::TruncSatSFloat32ToInt32)"), + ("i32.trunc_sat_f32_u", "makeUnary(s, UnaryOp::TruncSatUFloat32ToInt32)"), + ("i32.trunc_sat_f64_s", "makeUnary(s, UnaryOp::TruncSatSFloat64ToInt32)"), + ("i32.trunc_sat_f64_u", "makeUnary(s, UnaryOp::TruncSatUFloat64ToInt32)"), + ("i64.trunc_sat_f32_s", "makeUnary(s, UnaryOp::TruncSatSFloat32ToInt64)"), + ("i64.trunc_sat_f32_u", "makeUnary(s, UnaryOp::TruncSatUFloat32ToInt64)"), + ("i64.trunc_sat_f64_s", "makeUnary(s, UnaryOp::TruncSatSFloat64ToInt64)"), + ("i64.trunc_sat_f64_u", "makeUnary(s, UnaryOp::TruncSatUFloat64ToInt64)"), + # SIMD ops + ("v128.load", "makeLoad(s, Type::v128, /*isAtomic=*/false)"), + ("v128.store", "makeStore(s, Type::v128, /*isAtomic=*/false)"), + ("v128.const", "makeConst(s, Type::v128)"), + ("v8x16.shuffle", "makeSIMDShuffle(s)"), + ("i8x16.splat", "makeUnary(s, UnaryOp::SplatVecI8x16)"), + ("i8x16.extract_lane_s", "makeSIMDExtract(s, SIMDExtractOp::ExtractLaneSVecI8x16, 16)"), + ("i8x16.extract_lane_u", "makeSIMDExtract(s, SIMDExtractOp::ExtractLaneUVecI8x16, 16)"), + ("i8x16.replace_lane", "makeSIMDReplace(s, SIMDReplaceOp::ReplaceLaneVecI8x16, 16)"), + ("i16x8.splat", "makeUnary(s, UnaryOp::SplatVecI16x8)"), + ("i16x8.extract_lane_s", "makeSIMDExtract(s, SIMDExtractOp::ExtractLaneSVecI16x8, 8)"), + ("i16x8.extract_lane_u", "makeSIMDExtract(s, SIMDExtractOp::ExtractLaneUVecI16x8, 8)"), + ("i16x8.replace_lane", "makeSIMDReplace(s, SIMDReplaceOp::ReplaceLaneVecI16x8, 8)"), + ("i32x4.splat", "makeUnary(s, UnaryOp::SplatVecI32x4)"), + ("i32x4.extract_lane", "makeSIMDExtract(s, SIMDExtractOp::ExtractLaneVecI32x4, 4)"), + ("i32x4.replace_lane", "makeSIMDReplace(s, SIMDReplaceOp::ReplaceLaneVecI32x4, 4)"), + ("i64x2.splat", "makeUnary(s, UnaryOp::SplatVecI64x2)"), + ("i64x2.extract_lane", "makeSIMDExtract(s, SIMDExtractOp::ExtractLaneVecI64x2, 2)"), + ("i64x2.replace_lane", "makeSIMDReplace(s, SIMDReplaceOp::ReplaceLaneVecI64x2, 2)"), + ("f32x4.splat", "makeUnary(s, UnaryOp::SplatVecF32x4)"), + ("f32x4.extract_lane", "makeSIMDExtract(s, SIMDExtractOp::ExtractLaneVecF32x4, 4)"), + ("f32x4.replace_lane", "makeSIMDReplace(s, SIMDReplaceOp::ReplaceLaneVecF32x4, 4)"), + ("f64x2.splat", "makeUnary(s, UnaryOp::SplatVecF64x2)"), + ("f64x2.extract_lane", "makeSIMDExtract(s, SIMDExtractOp::ExtractLaneVecF64x2, 2)"), + ("f64x2.replace_lane", "makeSIMDReplace(s, SIMDReplaceOp::ReplaceLaneVecF64x2, 2)"), + ("i8x16.eq", "makeBinary(s, BinaryOp::EqVecI8x16)"), + ("i8x16.ne", "makeBinary(s, BinaryOp::NeVecI8x16)"), + ("i8x16.lt_s", "makeBinary(s, BinaryOp::LtSVecI8x16)"), + ("i8x16.lt_u", "makeBinary(s, BinaryOp::LtUVecI8x16)"), + ("i8x16.gt_s", "makeBinary(s, BinaryOp::GtSVecI8x16)"), + ("i8x16.gt_u", "makeBinary(s, BinaryOp::GtUVecI8x16)"), + ("i8x16.le_s", "makeBinary(s, BinaryOp::LeSVecI8x16)"), + ("i8x16.le_u", "makeBinary(s, BinaryOp::LeUVecI8x16)"), + ("i8x16.ge_s", "makeBinary(s, BinaryOp::GeSVecI8x16)"), + ("i8x16.ge_u", "makeBinary(s, BinaryOp::GeUVecI8x16)"), + ("i16x8.eq", "makeBinary(s, BinaryOp::EqVecI16x8)"), + ("i16x8.ne", "makeBinary(s, BinaryOp::NeVecI16x8)"), + ("i16x8.lt_s", "makeBinary(s, BinaryOp::LtSVecI16x8)"), + ("i16x8.lt_u", "makeBinary(s, BinaryOp::LtUVecI16x8)"), + ("i16x8.gt_s", "makeBinary(s, BinaryOp::GtSVecI16x8)"), + ("i16x8.gt_u", "makeBinary(s, BinaryOp::GtUVecI16x8)"), + ("i16x8.le_s", "makeBinary(s, BinaryOp::LeSVecI16x8)"), + ("i16x8.le_u", "makeBinary(s, BinaryOp::LeUVecI16x8)"), + ("i16x8.ge_s", "makeBinary(s, BinaryOp::GeSVecI16x8)"), + ("i16x8.ge_u", "makeBinary(s, BinaryOp::GeUVecI16x8)"), + ("i32x4.eq", "makeBinary(s, BinaryOp::EqVecI32x4)"), + ("i32x4.ne", "makeBinary(s, BinaryOp::NeVecI32x4)"), + ("i32x4.lt_s", "makeBinary(s, BinaryOp::LtSVecI32x4)"), + ("i32x4.lt_u", "makeBinary(s, BinaryOp::LtUVecI32x4)"), + ("i32x4.gt_s", "makeBinary(s, BinaryOp::GtSVecI32x4)"), + ("i32x4.gt_u", "makeBinary(s, BinaryOp::GtUVecI32x4)"), + ("i32x4.le_s", "makeBinary(s, BinaryOp::LeSVecI32x4)"), + ("i32x4.le_u", "makeBinary(s, BinaryOp::LeUVecI32x4)"), + ("i32x4.ge_s", "makeBinary(s, BinaryOp::GeSVecI32x4)"), + ("i32x4.ge_u", "makeBinary(s, BinaryOp::GeUVecI32x4)"), + ("f32x4.eq", "makeBinary(s, BinaryOp::EqVecF32x4)"), + ("f32x4.ne", "makeBinary(s, BinaryOp::NeVecF32x4)"), + ("f32x4.lt", "makeBinary(s, BinaryOp::LtVecF32x4)"), + ("f32x4.gt", "makeBinary(s, BinaryOp::GtVecF32x4)"), + ("f32x4.le", "makeBinary(s, BinaryOp::LeVecF32x4)"), + ("f32x4.ge", "makeBinary(s, BinaryOp::GeVecF32x4)"), + ("f64x2.eq", "makeBinary(s, BinaryOp::EqVecF64x2)"), + ("f64x2.ne", "makeBinary(s, BinaryOp::NeVecF64x2)"), + ("f64x2.lt", "makeBinary(s, BinaryOp::LtVecF64x2)"), + ("f64x2.gt", "makeBinary(s, BinaryOp::GtVecF64x2)"), + ("f64x2.le", "makeBinary(s, BinaryOp::LeVecF64x2)"), + ("f64x2.ge", "makeBinary(s, BinaryOp::GeVecF64x2)"), + ("v128.not", "makeUnary(s, UnaryOp::NotVec128)"), + ("v128.and", "makeBinary(s, BinaryOp::AndVec128)"), + ("v128.or", "makeBinary(s, BinaryOp::OrVec128)"), + ("v128.xor", "makeBinary(s, BinaryOp::XorVec128)"), + ("v128.andnot", "makeBinary(s, BinaryOp::AndNotVec128)"), + ("v128.bitselect", "makeSIMDTernary(s, SIMDTernaryOp::Bitselect)"), + ("i8x16.abs", "makeUnary(s, UnaryOp::AbsVecI8x16)"), + ("i8x16.neg", "makeUnary(s, UnaryOp::NegVecI8x16)"), + ("i8x16.any_true", "makeUnary(s, UnaryOp::AnyTrueVecI8x16)"), + ("i8x16.all_true", "makeUnary(s, UnaryOp::AllTrueVecI8x16)"), + ("i8x16.bitmask", "makeUnary(s, UnaryOp::BitmaskVecI8x16)"), + ("i8x16.shl", "makeSIMDShift(s, SIMDShiftOp::ShlVecI8x16)"), + ("i8x16.shr_s", "makeSIMDShift(s, SIMDShiftOp::ShrSVecI8x16)"), + ("i8x16.shr_u", "makeSIMDShift(s, SIMDShiftOp::ShrUVecI8x16)"), + ("i8x16.add", "makeBinary(s, BinaryOp::AddVecI8x16)"), + ("i8x16.add_saturate_s", "makeBinary(s, BinaryOp::AddSatSVecI8x16)"), + ("i8x16.add_saturate_u", "makeBinary(s, BinaryOp::AddSatUVecI8x16)"), + ("i8x16.sub", "makeBinary(s, BinaryOp::SubVecI8x16)"), + ("i8x16.sub_saturate_s", "makeBinary(s, BinaryOp::SubSatSVecI8x16)"), + ("i8x16.sub_saturate_u", "makeBinary(s, BinaryOp::SubSatUVecI8x16)"), + ("i8x16.mul", "makeBinary(s, BinaryOp::MulVecI8x16)"), + ("i8x16.min_s", "makeBinary(s, BinaryOp::MinSVecI8x16)"), + ("i8x16.min_u", "makeBinary(s, BinaryOp::MinUVecI8x16)"), + ("i8x16.max_s", "makeBinary(s, BinaryOp::MaxSVecI8x16)"), + ("i8x16.max_u", "makeBinary(s, BinaryOp::MaxUVecI8x16)"), + ("i8x16.avgr_u", "makeBinary(s, BinaryOp::AvgrUVecI8x16)"), + ("i16x8.abs", "makeUnary(s, UnaryOp::AbsVecI16x8)"), + ("i16x8.neg", "makeUnary(s, UnaryOp::NegVecI16x8)"), + ("i16x8.any_true", "makeUnary(s, UnaryOp::AnyTrueVecI16x8)"), + ("i16x8.all_true", "makeUnary(s, UnaryOp::AllTrueVecI16x8)"), + ("i16x8.bitmask", "makeUnary(s, UnaryOp::BitmaskVecI16x8)"), + ("i16x8.shl", "makeSIMDShift(s, SIMDShiftOp::ShlVecI16x8)"), + ("i16x8.shr_s", "makeSIMDShift(s, SIMDShiftOp::ShrSVecI16x8)"), + ("i16x8.shr_u", "makeSIMDShift(s, SIMDShiftOp::ShrUVecI16x8)"), + ("i16x8.add", "makeBinary(s, BinaryOp::AddVecI16x8)"), + ("i16x8.add_saturate_s", "makeBinary(s, BinaryOp::AddSatSVecI16x8)"), + ("i16x8.add_saturate_u", "makeBinary(s, BinaryOp::AddSatUVecI16x8)"), + ("i16x8.sub", "makeBinary(s, BinaryOp::SubVecI16x8)"), + ("i16x8.sub_saturate_s", "makeBinary(s, BinaryOp::SubSatSVecI16x8)"), + ("i16x8.sub_saturate_u", "makeBinary(s, BinaryOp::SubSatUVecI16x8)"), + ("i16x8.mul", "makeBinary(s, BinaryOp::MulVecI16x8)"), + ("i16x8.min_s", "makeBinary(s, BinaryOp::MinSVecI16x8)"), + ("i16x8.min_u", "makeBinary(s, BinaryOp::MinUVecI16x8)"), + ("i16x8.max_s", "makeBinary(s, BinaryOp::MaxSVecI16x8)"), + ("i16x8.max_u", "makeBinary(s, BinaryOp::MaxUVecI16x8)"), + ("i16x8.avgr_u", "makeBinary(s, BinaryOp::AvgrUVecI16x8)"), + ("i32x4.abs", "makeUnary(s, UnaryOp::AbsVecI32x4)"), + ("i32x4.neg", "makeUnary(s, UnaryOp::NegVecI32x4)"), + ("i32x4.any_true", "makeUnary(s, UnaryOp::AnyTrueVecI32x4)"), + ("i32x4.all_true", "makeUnary(s, UnaryOp::AllTrueVecI32x4)"), + ("i32x4.bitmask", "makeUnary(s, UnaryOp::BitmaskVecI32x4)"), + ("i32x4.shl", "makeSIMDShift(s, SIMDShiftOp::ShlVecI32x4)"), + ("i32x4.shr_s", "makeSIMDShift(s, SIMDShiftOp::ShrSVecI32x4)"), + ("i32x4.shr_u", "makeSIMDShift(s, SIMDShiftOp::ShrUVecI32x4)"), + ("i32x4.add", "makeBinary(s, BinaryOp::AddVecI32x4)"), + ("i32x4.sub", "makeBinary(s, BinaryOp::SubVecI32x4)"), + ("i32x4.mul", "makeBinary(s, BinaryOp::MulVecI32x4)"), + ("i32x4.min_s", "makeBinary(s, BinaryOp::MinSVecI32x4)"), + ("i32x4.min_u", "makeBinary(s, BinaryOp::MinUVecI32x4)"), + ("i32x4.max_s", "makeBinary(s, BinaryOp::MaxSVecI32x4)"), + ("i32x4.max_u", "makeBinary(s, BinaryOp::MaxUVecI32x4)"), + ("i32x4.dot_i16x8_s", "makeBinary(s, BinaryOp::DotSVecI16x8ToVecI32x4)"), + ("i64x2.neg", "makeUnary(s, UnaryOp::NegVecI64x2)"), + ("i64x2.any_true", "makeUnary(s, UnaryOp::AnyTrueVecI64x2)"), + ("i64x2.all_true", "makeUnary(s, UnaryOp::AllTrueVecI64x2)"), + ("i64x2.shl", "makeSIMDShift(s, SIMDShiftOp::ShlVecI64x2)"), + ("i64x2.shr_s", "makeSIMDShift(s, SIMDShiftOp::ShrSVecI64x2)"), + ("i64x2.shr_u", "makeSIMDShift(s, SIMDShiftOp::ShrUVecI64x2)"), + ("i64x2.add", "makeBinary(s, BinaryOp::AddVecI64x2)"), + ("i64x2.sub", "makeBinary(s, BinaryOp::SubVecI64x2)"), + ("i64x2.mul", "makeBinary(s, BinaryOp::MulVecI64x2)"), + ("f32x4.abs", "makeUnary(s, UnaryOp::AbsVecF32x4)"), + ("f32x4.neg", "makeUnary(s, UnaryOp::NegVecF32x4)"), + ("f32x4.sqrt", "makeUnary(s, UnaryOp::SqrtVecF32x4)"), + ("f32x4.qfma", "makeSIMDTernary(s, SIMDTernaryOp::QFMAF32x4)"), + ("f32x4.qfms", "makeSIMDTernary(s, SIMDTernaryOp::QFMSF32x4)"), + ("f32x4.add", "makeBinary(s, BinaryOp::AddVecF32x4)"), + ("f32x4.sub", "makeBinary(s, BinaryOp::SubVecF32x4)"), + ("f32x4.mul", "makeBinary(s, BinaryOp::MulVecF32x4)"), + ("f32x4.div", "makeBinary(s, BinaryOp::DivVecF32x4)"), + ("f32x4.min", "makeBinary(s, BinaryOp::MinVecF32x4)"), + ("f32x4.max", "makeBinary(s, BinaryOp::MaxVecF32x4)"), + ("f32x4.pmin", "makeBinary(s, BinaryOp::PMinVecF32x4)"), + ("f32x4.pmax", "makeBinary(s, BinaryOp::PMaxVecF32x4)"), + ("f32x4.ceil", "makeUnary(s, UnaryOp::CeilVecF32x4)"), + ("f32x4.floor", "makeUnary(s, UnaryOp::FloorVecF32x4)"), + ("f32x4.trunc", "makeUnary(s, UnaryOp::TruncVecF32x4)"), + ("f32x4.nearest", "makeUnary(s, UnaryOp::NearestVecF32x4)"), + ("f64x2.abs", "makeUnary(s, UnaryOp::AbsVecF64x2)"), + ("f64x2.neg", "makeUnary(s, UnaryOp::NegVecF64x2)"), + ("f64x2.sqrt", "makeUnary(s, UnaryOp::SqrtVecF64x2)"), + ("f64x2.qfma", "makeSIMDTernary(s, SIMDTernaryOp::QFMAF64x2)"), + ("f64x2.qfms", "makeSIMDTernary(s, SIMDTernaryOp::QFMSF64x2)"), + ("f64x2.add", "makeBinary(s, BinaryOp::AddVecF64x2)"), + ("f64x2.sub", "makeBinary(s, BinaryOp::SubVecF64x2)"), + ("f64x2.mul", "makeBinary(s, BinaryOp::MulVecF64x2)"), + ("f64x2.div", "makeBinary(s, BinaryOp::DivVecF64x2)"), + ("f64x2.min", "makeBinary(s, BinaryOp::MinVecF64x2)"), + ("f64x2.max", "makeBinary(s, BinaryOp::MaxVecF64x2)"), + ("f64x2.pmin", "makeBinary(s, BinaryOp::PMinVecF64x2)"), + ("f64x2.pmax", "makeBinary(s, BinaryOp::PMaxVecF64x2)"), + ("f64x2.ceil", "makeUnary(s, UnaryOp::CeilVecF64x2)"), + ("f64x2.floor", "makeUnary(s, UnaryOp::FloorVecF64x2)"), + ("f64x2.trunc", "makeUnary(s, UnaryOp::TruncVecF64x2)"), + ("f64x2.nearest", "makeUnary(s, UnaryOp::NearestVecF64x2)"), + ("i32x4.trunc_sat_f32x4_s", "makeUnary(s, UnaryOp::TruncSatSVecF32x4ToVecI32x4)"), + ("i32x4.trunc_sat_f32x4_u", "makeUnary(s, UnaryOp::TruncSatUVecF32x4ToVecI32x4)"), + ("i64x2.trunc_sat_f64x2_s", "makeUnary(s, UnaryOp::TruncSatSVecF64x2ToVecI64x2)"), + ("i64x2.trunc_sat_f64x2_u", "makeUnary(s, UnaryOp::TruncSatUVecF64x2ToVecI64x2)"), + ("f32x4.convert_i32x4_s", "makeUnary(s, UnaryOp::ConvertSVecI32x4ToVecF32x4)"), + ("f32x4.convert_i32x4_u", "makeUnary(s, UnaryOp::ConvertUVecI32x4ToVecF32x4)"), + ("f64x2.convert_i64x2_s", "makeUnary(s, UnaryOp::ConvertSVecI64x2ToVecF64x2)"), + ("f64x2.convert_i64x2_u", "makeUnary(s, UnaryOp::ConvertUVecI64x2ToVecF64x2)"), + ("v8x16.load_splat", "makeSIMDLoad(s, SIMDLoadOp::LoadSplatVec8x16)"), + ("v16x8.load_splat", "makeSIMDLoad(s, SIMDLoadOp::LoadSplatVec16x8)"), + ("v32x4.load_splat", "makeSIMDLoad(s, SIMDLoadOp::LoadSplatVec32x4)"), + ("v64x2.load_splat", "makeSIMDLoad(s, SIMDLoadOp::LoadSplatVec64x2)"), + ("i16x8.load8x8_s", "makeSIMDLoad(s, SIMDLoadOp::LoadExtSVec8x8ToVecI16x8)"), + ("i16x8.load8x8_u", "makeSIMDLoad(s, SIMDLoadOp::LoadExtUVec8x8ToVecI16x8)"), + ("i32x4.load16x4_s", "makeSIMDLoad(s, SIMDLoadOp::LoadExtSVec16x4ToVecI32x4)"), + ("i32x4.load16x4_u", "makeSIMDLoad(s, SIMDLoadOp::LoadExtUVec16x4ToVecI32x4)"), + ("i64x2.load32x2_s", "makeSIMDLoad(s, SIMDLoadOp::LoadExtSVec32x2ToVecI64x2)"), + ("i64x2.load32x2_u", "makeSIMDLoad(s, SIMDLoadOp::LoadExtUVec32x2ToVecI64x2)"), + ("v128.load32_zero", "makeSIMDLoad(s, SIMDLoadOp::Load32Zero)"), + ("v128.load64_zero", "makeSIMDLoad(s, SIMDLoadOp::Load64Zero)"), + ("i8x16.narrow_i16x8_s", "makeBinary(s, BinaryOp::NarrowSVecI16x8ToVecI8x16)"), + ("i8x16.narrow_i16x8_u", "makeBinary(s, BinaryOp::NarrowUVecI16x8ToVecI8x16)"), + ("i16x8.narrow_i32x4_s", "makeBinary(s, BinaryOp::NarrowSVecI32x4ToVecI16x8)"), + ("i16x8.narrow_i32x4_u", "makeBinary(s, BinaryOp::NarrowUVecI32x4ToVecI16x8)"), + ("i16x8.widen_low_i8x16_s", "makeUnary(s, UnaryOp::WidenLowSVecI8x16ToVecI16x8)"), + ("i16x8.widen_high_i8x16_s", "makeUnary(s, UnaryOp::WidenHighSVecI8x16ToVecI16x8)"), + ("i16x8.widen_low_i8x16_u", "makeUnary(s, UnaryOp::WidenLowUVecI8x16ToVecI16x8)"), + ("i16x8.widen_high_i8x16_u", "makeUnary(s, UnaryOp::WidenHighUVecI8x16ToVecI16x8)"), + ("i32x4.widen_low_i16x8_s", "makeUnary(s, UnaryOp::WidenLowSVecI16x8ToVecI32x4)"), + ("i32x4.widen_high_i16x8_s", "makeUnary(s, UnaryOp::WidenHighSVecI16x8ToVecI32x4)"), + ("i32x4.widen_low_i16x8_u", "makeUnary(s, UnaryOp::WidenLowUVecI16x8ToVecI32x4)"), + ("i32x4.widen_high_i16x8_u", "makeUnary(s, UnaryOp::WidenHighUVecI16x8ToVecI32x4)"), + ("v8x16.swizzle", "makeBinary(s, BinaryOp::SwizzleVec8x16)"), + # reference types instructions + # TODO Add table instructions + ("ref.null", "makeRefNull(s)"), + ("ref.is_null", "makeRefIsNull(s)"), + ("ref.func", "makeRefFunc(s)"), + # exception handling instructions + ("try", "makeTry(s)"), + ("throw", "makeThrow(s)"), + ("rethrow", "makeRethrow(s)"), + ("br_on_exn", "makeBrOnExn(s)"), + # Multivalue pseudoinstructions + ("tuple.make", "makeTupleMake(s)"), + ("tuple.extract", "makeTupleExtract(s)"), + ("pop", "makePop(s)"), + # GC + ("ref.eq", "makeRefEq(s)"), + ("i31.new", "makeI31New(s)"), + ("i31.get_s", "makeI31Get(s, true)"), + ("i31.get_u", "makeI31Get(s, false)"), + ("ref.test", "makeRefTest(s)"), + ("ref.cast", "makeRefCast(s)"), + ("br_on_cast", "makeBrOnCast(s)"), + ("rtt.canon", "makeRttCanon(s)"), + ("rtt.sub", "makeRttSub(s)"), + ("struct.new_with_rtt", "makeStructNew(s, false)"), + ("struct.new_default_with_rtt", "makeStructNew(s, true)"), + ("struct.get", "makeStructGet(s)"), + ("struct.get_s", "makeStructGet(s, true)"), + ("struct.get_u", "makeStructGet(s, false)"), + ("struct.set", "makeStructSet(s)"), + ("array.new_with_rtt", "makeArrayNew(s, false)"), + ("array.new_default_with_rtt", "makeArrayNew(s, true)"), + ("array.get", "makeArrayGet(s)"), + ("array.get_s", "makeArrayGet(s, true)"), + ("array.get_u", "makeArrayGet(s, false)"), + ("array.set", "makeArraySet(s)"), + ("array.len", "makeArrayLen(s)") +] + + +class CodePrinter: + indents = 0 + + def __enter__(self): + CodePrinter.indents += 1 + + def __exit__(self, *args): + CodePrinter.indents -= 1 + + def indent(self): + # call in a 'with' statement + return self + + def print_line(self, line): + print(" " * CodePrinter.indents + line) + + +class Node: + def __init__(self, expr=None, children=None, inst=None): + # the expression to return if this is the string has ended + self.expr = expr + # map unique strings to children nodes + self.children = children if children else {} + # full instruction leading to this node + self.inst = inst + + def _common_prefix(a, b): + """Return the common prefix of two strings.""" + prefix = [] + while a and b and a[0] == b[0]: + prefix.append(a[0]) + a = a[1:] + b = b[1:] + return "".join(prefix) + + def do_insert(self, full_inst, inst, expr): + if not inst: + assert self.expr is None, "Repeated instruction " + full_inst + self.expr = expr + self.inst = full_inst + return + # find key with shared prefix + prefix, key = "", None + for k in self.children: + prefix = Node._common_prefix(inst, k) + if prefix: + key = k + break + if key is None: + # unique prefix, insert and stop + self.children[inst] = Node(expr, inst=full_inst) + return + key_remainder = key[len(prefix):] + if key_remainder: + # split key and move everything after the prefix to a new node + child = self.children.pop(key) + self.children[prefix] = Node(children={key_remainder: child}) + # update key for recursive insert + key = prefix + # chop off prefix and recurse + self.children[key].do_insert(full_inst, inst[len(key):], expr) + + def insert(self, inst, expr): + self.do_insert(inst, inst, expr) + + +def instruction_parser(): + """Build a trie out of all the instructions, then emit it as C++ code.""" + trie = Node() + inst_length = 0 + for inst, expr in instructions: + inst_length = max(inst_length, len(inst)) + trie.insert(inst, expr) + + printer = CodePrinter() + + printer.print_line("char op[{}] = {{'\\0'}};".format(inst_length + 1)) + printer.print_line("strncpy(op, s[0]->c_str(), {});".format(inst_length)) + + def print_leaf(expr, inst): + printer.print_line("if (strcmp(op, \"{inst}\") == 0) {{ return {expr}; }}" + .format(inst=inst, expr=expr)) + printer.print_line("goto parse_error;") + + def emit(node, idx=0): + assert node.children + printer.print_line("switch (op[{}]) {{".format(idx)) + with printer.indent(): + if node.expr: + printer.print_line("case '\\0':") + with printer.indent(): + print_leaf(node.expr, node.inst) + children = sorted(node.children.items(), key=lambda pair: pair[0]) + for prefix, child in children: + if child.children: + printer.print_line("case '{}': {{".format(prefix[0])) + with printer.indent(): + emit(child, idx + len(prefix)) + printer.print_line("}") + else: + assert child.expr + printer.print_line("case '{}':".format(prefix[0])) + with printer.indent(): + print_leaf(child.expr, child.inst) + printer.print_line("default: goto parse_error;") + printer.print_line("}") + + emit(trie) + printer.print_line("parse_error:") + with printer.indent(): + printer.print_line("throw ParseException(std::string(op), s.line, s.col);") + + +def print_header(): + print("// DO NOT EDIT! This file generated by scripts/gen-s-parser.py\n") + print("// clang-format off\n") + + +def print_footer(): + print("\n// clang-format on") + + +def generate_with_guard(generator, guard): + print("#ifdef {}".format(guard)) + print("#undef {}".format(guard)) + generator() + print("#endif // {}".format(guard)) + + +def main(): + if sys.version_info.major != 3: + import datetime + print("It's " + str(datetime.datetime.now().year) + "! Use Python 3!") + sys.exit(1) + print_header() + generate_with_guard(instruction_parser, "INSTRUCTION_PARSER") + print_footer() + + +if __name__ == "__main__": + main() diff --git a/binaryen/scripts/process_optimize_instructions.py b/binaryen/scripts/process_optimize_instructions.py new file mode 100644 --- /dev/null +++ b/binaryen/scripts/process_optimize_instructions.py @@ -0,0 +1,16 @@ +#!/usr/bin/python + +import os + +root = os.path.dirname(os.path.dirname(__file__)) + +infile = os.path.join(root, 'src', 'passes', 'OptimizeInstructions.wast') +outfile = os.path.join(root, 'src', 'passes', + 'OptimizeInstructions.wast.processed') + +out = open(outfile, 'w') + +for line in open(infile): + out.write('"' + line.strip().replace('"', '\\"') + '\\n"\n') + +out.close() diff --git a/binaryen/scripts/storage.py b/binaryen/scripts/storage.py new file mode 100644 --- /dev/null +++ b/binaryen/scripts/storage.py @@ -0,0 +1,55 @@ +#!/usr/bin/env python3 +# +# Copyright 2016 WebAssembly Community Group participants +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from __future__ import print_function + +import glob +import json +import os +import urllib2 + + +STORAGE_BASE = 'https://storage.googleapis.com/wasm-llvm/builds/git/' + + +def download_revision(force_latest): + name = 'latest' if force_latest else 'lkgr' + downloaded = urllib2.urlopen(STORAGE_BASE + name).read().strip() + # TODO: for now try opening as JSON, if that doesn't work then the content is + # just a hash. The waterfall is in the process of migrating to JSON. + info = None + try: + info = json.loads(downloaded) + except ValueError: + pass + return info['build'] if type(info) == dict else downloaded + + +def download_tar(tar_pattern, directory, revision): + tar_path = os.path.join(directory, tar_pattern) + revision_tar_path = tar_path % revision + if os.path.isfile(revision_tar_path): + print('Already have `%s`' % revision_tar_path) + else: + print('Downloading `%s`' % revision_tar_path) + with open(revision_tar_path, 'w+') as f: + f.write(urllib2.urlopen(STORAGE_BASE + tar_pattern % revision).read()) + # Remove any previous tarfiles. + for older_tar in glob.glob(tar_path % '*'): + if older_tar != revision_tar_path: + print('Removing older tar file `%s`' % older_tar) + os.remove(older_tar) + return revision_tar_path diff --git a/binaryen/scripts/strip_local_names.py b/binaryen/scripts/strip_local_names.py new file mode 100644 --- /dev/null +++ b/binaryen/scripts/strip_local_names.py @@ -0,0 +1,12 @@ + +"""Removes local names. When you don't care about local names but do want +to diff for structural changes, this can help. +""" + +import sys + +for line in open(sys.argv[1]).readlines(): + if '(local.tee ' in line or '(local.set ' in line or '(local.get ' in line: + print(line[:line.find('$')]) + else: + print(line.rstrip()) diff --git a/binaryen/scripts/test/__init__.py b/binaryen/scripts/test/__init__.py new file mode 100644 --- /dev/null +++ b/binaryen/scripts/test/__init__.py @@ -0,0 +1,15 @@ +# Copyright 2015 WebAssembly Community Group participants +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# Empty __init__.py file: Python treats the directory as containing a package. diff --git a/binaryen/scripts/test/binaryenjs.py b/binaryen/scripts/test/binaryenjs.py new file mode 100644 --- /dev/null +++ b/binaryen/scripts/test/binaryenjs.py @@ -0,0 +1,106 @@ +# Copyright 2016 WebAssembly Community Group participants +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import os +import subprocess + +from . import shared +from . import support + + +def do_test_binaryen_js_with(which): + if not (shared.MOZJS or shared.NODEJS): + shared.fail_with_error('no vm to run binaryen.js tests') + + node_has_wasm = shared.NODEJS and support.node_has_webassembly(shared.NODEJS) + if not os.path.exists(which): + shared.fail_with_error('no ' + which + ' build to test') + + print('\n[ checking binaryen.js testcases (' + which + ')... ]\n') + + for s in sorted(os.listdir(os.path.join(shared.options.binaryen_test, 'binaryen.js'))): + if not s.endswith('.js'): + continue + print(s) + f = open('a.js', 'w') + # avoid stdout/stderr ordering issues in some js shells - use just stdout + f.write(''' + console.warn = console.error = console.log; + ''') + binaryen_js = open(which).read() + f.write(binaryen_js) + test_path = os.path.join(shared.options.binaryen_test, 'binaryen.js', s) + test_src = open(test_path).read() + f.write(support.js_test_wrap().replace('%TEST%', test_src)) + f.close() + + def test(engine): + cmd = [engine, 'a.js'] + if 'fatal' not in s: + out = support.run_command(cmd, stderr=subprocess.STDOUT) + else: + # expect an error - the specific error code will depend on the vm + out = support.run_command(cmd, stderr=subprocess.STDOUT, expected_status=None) + expected = open(os.path.join(shared.options.binaryen_test, 'binaryen.js', s + '.txt')).read() + if expected not in out: + shared.fail(out, expected) + + # run in all possible shells + if shared.MOZJS: + test(shared.MOZJS) + if shared.NODEJS: + if node_has_wasm or 'WebAssembly.' not in test_src: + test(shared.NODEJS) + else: + print('Skipping ' + test_path + ' because WebAssembly might not be supported') + + +def update_binaryen_js_tests(): + if not (shared.MOZJS or shared.NODEJS): + print('no vm to run binaryen.js tests') + return + + if not os.path.exists(shared.BINARYEN_JS): + print('no binaryen.js build to test') + return + + print('\n[ checking binaryen.js testcases... ]\n') + node_has_wasm = shared.NODEJS and support.node_has_webassembly(shared.NODEJS) + for s in shared.get_tests(shared.get_test_dir('binaryen.js'), ['.js']): + basename = os.path.basename(s) + print(basename) + f = open('a.js', 'w') + f.write(open(shared.BINARYEN_JS).read()) + test_src = open(s).read() + f.write(support.js_test_wrap().replace('%TEST%', test_src)) + f.close() + if shared.MOZJS or node_has_wasm or 'WebAssembly.' not in test_src: + cmd = [shared.MOZJS or shared.NODEJS, 'a.js'] + if 'fatal' not in basename: + out = support.run_command(cmd, stderr=subprocess.STDOUT) + else: + # expect an error - the specific error code will depend on the vm + out = support.run_command(cmd, stderr=subprocess.STDOUT, expected_status=None) + with open(s + '.txt', 'w') as o: + o.write(out) + else: + print('Skipping ' + basename + ' because WebAssembly might not be supported') + + +def test_binaryen_js(): + do_test_binaryen_js_with(shared.BINARYEN_JS) + + +def test_binaryen_wasm(): + do_test_binaryen_js_with(shared.BINARYEN_WASM) diff --git a/binaryen/scripts/test/env.js b/binaryen/scripts/test/env.js new file mode 100644 --- /dev/null +++ b/binaryen/scripts/test/env.js @@ -0,0 +1,15 @@ +// This is the name by which the tests import the wasm table. +export const table = []; + +var tempRet0 = 0; + +export function setTempRet0(x) { + tempRet0 = x; +} + +export function getTempRet0() { + return tempRet0; +} + +export const memoryBase = 0; +export const tableBase = 0; diff --git a/binaryen/scripts/test/generate_lld_tests.py b/binaryen/scripts/test/generate_lld_tests.py new file mode 100644 --- /dev/null +++ b/binaryen/scripts/test/generate_lld_tests.py @@ -0,0 +1,99 @@ +#!/usr/bin/env python3 +# +# Copyright 2017 WebAssembly Community Group participants +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from __future__ import print_function + +import os +import sys + +import shared +import support + + +def files_with_extensions(path, extensions): + for file in sorted(os.listdir(path)): + ext = os.path.splitext(file)[1] + if ext in extensions: + yield file, ext + + +def generate_wat_files(llvm_bin, emscripten_root): + print('\n[ building wat files from C sources... ]\n') + + lld_path = os.path.join(shared.options.binaryen_test, 'lld') + for src_file, ext in files_with_extensions(lld_path, ['.c', '.cpp', '.s']): + print('..', src_file) + obj_file = src_file.replace(ext, '.o') + + src_path = os.path.join(lld_path, src_file) + obj_path = os.path.join(lld_path, obj_file) + + wasm_file = src_file.replace(ext, '.wasm') + wat_file = src_file.replace(ext, '.wat') + + obj_path = os.path.join(lld_path, obj_file) + wasm_path = os.path.join(lld_path, wasm_file) + wat_path = os.path.join(lld_path, wat_file) + is_shared = 'shared' in src_file + + compile_cmd = [ + os.path.join(llvm_bin, 'clang'), src_path, '-o', obj_path, + '--target=wasm32-emscripten', + '-mllvm', '-enable-emscripten-sjlj', + '-c', + '-nostdinc', + '-Xclang', '-nobuiltininc', + '-Xclang', '-nostdsysteminc', + '-Xclang', '-I%s/system/include' % emscripten_root, + '-O1', + ] + + link_cmd = [ + os.path.join(llvm_bin, 'wasm-ld'), '-flavor', 'wasm', + '-z', '-stack-size=1048576', + obj_path, '-o', wasm_path, + '--allow-undefined', + '--export', '__wasm_call_ctors', + '--export', '__data_end', + '--global-base=568', + ] + # We had a regression where this test only worked if debug names + # were included. + if 'longjmp' in src_file: + link_cmd.append('--strip-debug') + if is_shared: + compile_cmd.append('-fPIC') + compile_cmd.append('-fvisibility=default') + link_cmd.append('-shared') + link_cmd.append('--experimental-pic') + else: + link_cmd.append('--entry=main') + + try: + support.run_command(compile_cmd) + support.run_command(link_cmd) + support.run_command(shared.WASM_DIS + [wasm_path, '-o', wat_path]) + finally: + # Don't need the .o or .wasm files, don't leave them around + shared.delete_from_orbit(obj_path) + shared.delete_from_orbit(wasm_path) + + +if __name__ == '__main__': + if len(shared.options.positional_args) != 2: + print('Usage: generate_lld_tests.py [llvm/bin/dir] [path/to/emscripten]') + sys.exit(1) + generate_wat_files(*shared.options.positional_args) diff --git a/binaryen/scripts/test/lld.py b/binaryen/scripts/test/lld.py new file mode 100644 --- /dev/null +++ b/binaryen/scripts/test/lld.py @@ -0,0 +1,104 @@ +# Copyright 2017 WebAssembly Community Group participants +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import json +import os +from . import shared +from . import support + + +def args_for_finalize(filename): + ret = ['--global-base=568'] + if 'safe_stack' in filename: + ret += ['--check-stack-overflow'] + if 'shared' in filename: + ret += ['--side-module'] + if 'standalone-wasm' in filename: + ret += ['--standalone-wasm'] + if 'bigint' in filename: + ret += ['--bigint'] + return ret + + +def run_test(input_path): + print('..', input_path) + is_passive = '.passive.' in input_path + mem_file = input_path + '.mem' + extension_arg_map = { + '.out': [], + } + if not is_passive: + extension_arg_map.update({ + '.mem.out': ['--separate-data-segments', mem_file], + }) + for ext, args in extension_arg_map.items(): + expected_file = input_path + ext + if not os.path.exists(expected_file): + if ext == '.out': + shared.fail_with_error('output ' + expected_file + + ' does not exist') + else: + continue + + cmd = shared.WASM_EMSCRIPTEN_FINALIZE + [input_path, '-S'] + args + cmd += args_for_finalize(os.path.basename(input_path)) + actual = support.run_command(cmd) + + shared.fail_if_not_identical_to_file(actual, expected_file) + if ext == '.out': + start = actual.find('--BEGIN METADATA --\n') + end = actual.find('-- END METADATA --\n') + if start == -1 or end == -1: + shared.fail_with_error('json metadata tags not found') + the_json = actual[start + len('--BEGIN METADATA --\n'):end] + json.loads(the_json) + + if ext == '.mem.out': + with open(mem_file) as mf: + mem = mf.read() + shared.fail_if_not_identical_to_file(mem, input_path + '.mem.mem') + os.remove(mem_file) + + +def test_wasm_emscripten_finalize(): + print('\n[ checking wasm-emscripten-finalize testcases... ]\n') + + for input_path in shared.get_tests(shared.get_test_dir('lld'), ['.wat', '.wasm']): + run_test(input_path) + + +def update_lld_tests(): + print('\n[ updating wasm-emscripten-finalize testcases... ]\n') + + for input_path in shared.get_tests(shared.get_test_dir('lld'), ['.wat', '.wasm']): + print('..', input_path) + is_passive = '.passive.' in input_path + mem_file = input_path + '.mem' + extension_arg_map = { + '.out': [], + } + if not is_passive: + extension_arg_map.update({ + '.mem.out': ['--separate-data-segments', mem_file + '.mem'], + }) + for ext, ext_args in extension_arg_map.items(): + out_path = input_path + ext + if ext != '.out' and not os.path.exists(out_path): + continue + cmd = shared.WASM_EMSCRIPTEN_FINALIZE + [input_path, '-S'] + \ + ext_args + cmd += args_for_finalize(os.path.basename(input_path)) + actual = support.run_command(cmd) + with open(out_path, 'w') as o: + o.write(actual) diff --git a/binaryen/scripts/test/mod.ule.js b/binaryen/scripts/test/mod.ule.js new file mode 100644 --- /dev/null +++ b/binaryen/scripts/test/mod.ule.js @@ -0,0 +1,4 @@ + +export function ba_se() { + console.log('"mod.ule"."ba.se"'); +} diff --git a/binaryen/scripts/test/node-esm-loader.mjs b/binaryen/scripts/test/node-esm-loader.mjs new file mode 100644 --- /dev/null +++ b/binaryen/scripts/test/node-esm-loader.mjs @@ -0,0 +1,42 @@ +// originally lifted from https://nodejs.org/api/esm.html + +import path from 'path'; +import process from 'process'; + +const baseURL = new URL('file://'); +const binaryen_root = path.dirname(path.dirname(process.cwd())); +baseURL.pathname = `${binaryen_root}/`; + +const specialTestSuiteModules = { + 'spectest': { + url: new URL('scripts/test/spectest.js', baseURL).href, + format: 'module' + }, + 'env': { + url: new URL('scripts/test/env.js', baseURL).href, + format: 'module' + }, + 'mod.ule': { + url: new URL('scripts/test/mod.ule.js', baseURL).href, + format: 'module' + } +}; + +export async function resolve(specifier, context, defaultResolve) { + const specialModule = specialTestSuiteModules[specifier]; + if (specialModule) { + return specialModule; + } + return defaultResolve(specifier, context, defaultResolve); +} + +export async function getFormat(url, context, defaultGetFormat) { + const specifiers = Object.keys(specialTestSuiteModules); + for (let i = 0, k = specifiers.length; i < k; ++i) { + const specialModule = specialTestSuiteModules[specifiers[i]]; + if (specialModule.url == url) { + return specialModule; + } + } + return defaultGetFormat(url, context, defaultGetFormat); +} diff --git a/binaryen/scripts/test/shared.py b/binaryen/scripts/test/shared.py new file mode 100644 --- /dev/null +++ b/binaryen/scripts/test/shared.py @@ -0,0 +1,536 @@ +# Copyright 2015 WebAssembly Community Group participants +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from __future__ import print_function + +import argparse +import difflib +import fnmatch +import glob +import os +import shutil +import subprocess +import sys + +# The C++ standard whose features are required to build Binaryen. +# Keep in sync with CMakeLists.txt CXX_STANDARD +cxx_standard = 14 + + +def parse_args(args): + usage_str = ("usage: 'python check.py [options]'\n\n" + "Runs the Binaryen test suite.") + parser = argparse.ArgumentParser(description=usage_str) + parser.add_argument( + '--torture', dest='torture', action='store_true', default=True, + help='Chooses whether to run the torture testcases. Default: true.') + parser.add_argument( + '--no-torture', dest='torture', action='store_false', + help='Disables running the torture testcases.') + parser.add_argument( + '--abort-on-first-failure', dest='abort_on_first_failure', + action='store_true', default=True, + help=('Specifies whether to halt test suite execution on first test error.' + ' Default: true.')) + parser.add_argument( + '--no-abort-on-first-failure', dest='abort_on_first_failure', + action='store_false', + help=('If set, the whole test suite will run to completion independent of' + ' earlier errors.')) + parser.add_argument( + '--interpreter', dest='interpreter', default='', + help='Specifies the wasm interpreter executable to run tests on.') + parser.add_argument( + '--binaryen-bin', dest='binaryen_bin', default='', + help=('Specifies a path to where the built Binaryen executables reside at.' + ' Default: bin/ of current directory (i.e. assume an in-tree build).' + ' If not specified, the environment variable BINARYEN_ROOT= can also' + ' be used to adjust this.')) + parser.add_argument( + '--binaryen-root', dest='binaryen_root', default='', + help=('Specifies a path to the root of the Binaryen repository tree.' + ' Default: the directory where this file check.py resides.')) + parser.add_argument( + '--out-dir', dest='out_dir', default='', + help=('Specifies a path to the output directory for temp files, which ' + 'is also where the test runner changes directory into.' + ' Default:. out/test under the binaryen root.')) + parser.add_argument( + '--valgrind', dest='valgrind', default='', + help=('Specifies a path to Valgrind tool, which will be used to validate' + ' execution if specified. (Pass --valgrind=valgrind to search in' + ' PATH)')) + parser.add_argument( + '--valgrind-full-leak-check', dest='valgrind_full_leak_check', + action='store_true', default=False, + help=('If specified, all unfreed (but still referenced) pointers at the' + ' end of execution are considered memory leaks. Default: disabled.')) + parser.add_argument( + '--spec-test', action='append', nargs='*', default=[], dest='spec_tests', + help='Names specific spec tests to run.') + parser.add_argument( + 'positional_args', metavar='TEST_SUITE', nargs='*', + help=('Names specific test suites to run. Use --list-suites to see a ' + 'list of all test suites')) + parser.add_argument( + '--list-suites', action='store_true', + help='List the test suites that can be run.') + parser.add_argument( + '--filter', dest='test_name_filter', default='', + help=('Specifies a filter. Only tests whose paths contains this ' + 'substring will be run')) + + return parser.parse_args(args) + + +options = parse_args(sys.argv[1:]) +requested = options.positional_args +script_dir = os.path.dirname(os.path.abspath(__file__)) + +num_failures = 0 +warnings = [] + + +def warn(text): + global warnings + warnings.append(text) + print('warning:', text, file=sys.stderr) + + +# setup + +# Locate Binaryen build artifacts directory (bin/ by default) +if not options.binaryen_bin: + if os.environ.get('BINARYEN_ROOT'): + if os.path.isdir(os.path.join(os.environ.get('BINARYEN_ROOT'), 'bin')): + options.binaryen_bin = os.path.join( + os.environ.get('BINARYEN_ROOT'), 'bin') + else: + options.binaryen_bin = os.environ.get('BINARYEN_ROOT') + else: + options.binaryen_bin = 'bin' + +options.binaryen_bin = os.path.normpath(os.path.abspath(options.binaryen_bin)) + +# ensure BINARYEN_ROOT is set up +os.environ['BINARYEN_ROOT'] = os.path.dirname(options.binaryen_bin) + +wasm_dis_filenames = ['wasm-dis', 'wasm-dis.exe'] +if not any(os.path.isfile(os.path.join(options.binaryen_bin, f)) + for f in wasm_dis_filenames): + warn('Binaryen not found (or has not been successfully built to bin/ ?') + +# Locate Binaryen source directory if not specified. +if not options.binaryen_root: + options.binaryen_root = os.path.dirname(os.path.dirname(script_dir)) + +options.binaryen_test = os.path.join(options.binaryen_root, 'test') + +if not options.out_dir: + options.out_dir = os.path.join(options.binaryen_root, 'out', 'test') + +if not os.path.exists(options.out_dir): + os.makedirs(options.out_dir) +os.chdir(options.out_dir) + + +# Finds the given executable 'program' in PATH. +# Operates like the Unix tool 'which'. +def which(program): + def is_exe(fpath): + return os.path.isfile(fpath) and os.access(fpath, os.X_OK) + fpath, fname = os.path.split(program) + if fpath: + if is_exe(program): + return program + else: + paths = [ + # Prefer tools installed using third_party/setup.py + os.path.join(options.binaryen_root, 'third_party', 'mozjs'), + os.path.join(options.binaryen_root, 'third_party', 'v8'), + os.path.join(options.binaryen_root, 'third_party', 'wabt', 'bin') + ] + os.environ['PATH'].split(os.pathsep) + for path in paths: + path = path.strip('"') + exe_file = os.path.join(path, program) + if is_exe(exe_file): + return exe_file + if '.' not in fname: + if is_exe(exe_file + '.exe'): + return exe_file + '.exe' + if is_exe(exe_file + '.cmd'): + return exe_file + '.cmd' + if is_exe(exe_file + '.bat'): + return exe_file + '.bat' + + +WATERFALL_BUILD_DIR = os.path.join(options.binaryen_test, 'wasm-install') +BIN_DIR = os.path.abspath(os.path.join(WATERFALL_BUILD_DIR, 'wasm-install', 'bin')) + +NATIVECC = (os.environ.get('CC') or which('mingw32-gcc') or + which('gcc') or which('clang')) +NATIVEXX = (os.environ.get('CXX') or which('mingw32-g++') or + which('g++') or which('clang++')) +NODEJS = os.getenv('NODE', which('nodejs') or which('node')) +MOZJS = which('mozjs') or which('spidermonkey') +V8 = which('v8') or which('d8') + +BINARYEN_INSTALL_DIR = os.path.dirname(options.binaryen_bin) +WASM_OPT = [os.path.join(options.binaryen_bin, 'wasm-opt')] +WASM_AS = [os.path.join(options.binaryen_bin, 'wasm-as')] +WASM_DIS = [os.path.join(options.binaryen_bin, 'wasm-dis')] +ASM2WASM = [os.path.join(options.binaryen_bin, 'asm2wasm')] +WASM2JS = [os.path.join(options.binaryen_bin, 'wasm2js')] +WASM_CTOR_EVAL = [os.path.join(options.binaryen_bin, 'wasm-ctor-eval')] +WASM_SHELL = [os.path.join(options.binaryen_bin, 'wasm-shell')] +WASM_REDUCE = [os.path.join(options.binaryen_bin, 'wasm-reduce')] +WASM_METADCE = [os.path.join(options.binaryen_bin, 'wasm-metadce')] +WASM_EMSCRIPTEN_FINALIZE = [os.path.join(options.binaryen_bin, + 'wasm-emscripten-finalize')] +BINARYEN_JS = os.path.join(options.binaryen_bin, 'binaryen_js.js') +BINARYEN_WASM = os.path.join(options.binaryen_bin, 'binaryen_wasm.js') + + +def wrap_with_valgrind(cmd): + # Exit code 97 is arbitrary, used to easily detect when an error occurs that + # is detected by Valgrind. + valgrind = [options.valgrind, '--quiet', '--error-exitcode=97'] + if options.valgrind_full_leak_check: + valgrind += ['--leak-check=full', '--show-leak-kinds=all'] + return valgrind + cmd + + +if options.valgrind: + WASM_OPT = wrap_with_valgrind(WASM_OPT) + WASM_AS = wrap_with_valgrind(WASM_AS) + WASM_DIS = wrap_with_valgrind(WASM_DIS) + ASM2WASM = wrap_with_valgrind(ASM2WASM) + WASM_SHELL = wrap_with_valgrind(WASM_SHELL) + + +def in_binaryen(*args): + return os.path.join(options.binaryen_root, *args) + + +os.environ['BINARYEN'] = in_binaryen() + + +def get_platform(): + return {'linux': 'linux', + 'linux2': 'linux', + 'darwin': 'mac', + 'win32': 'windows', + 'cygwin': 'windows'}[sys.platform] + + +def has_shell_timeout(): + return get_platform() != 'windows' and os.system('timeout 1s pwd') == 0 + + +# Default options to pass to v8. These enable all features. +# See https://github.com/v8/v8/blob/master/src/wasm/wasm-feature-flags.h +V8_OPTS = [ + '--wasm-staging', + '--experimental-wasm-eh', + '--experimental-wasm-simd', + '--experimental-wasm-reftypes', + '--experimental-wasm-compilation-hints', + '--experimental-wasm-return-call' +] + +# external tools + +try: + if NODEJS is not None: + subprocess.check_call([NODEJS, '--version'], + stdout=subprocess.PIPE, + stderr=subprocess.PIPE) +except (OSError, subprocess.CalledProcessError): + NODEJS = None +if NODEJS is None: + warn('no node found (did not check proper js form)') + +try: + if MOZJS is not None: + subprocess.check_call([MOZJS, '--version'], + stdout=subprocess.PIPE, + stderr=subprocess.PIPE) +except (OSError, subprocess.CalledProcessError): + MOZJS = None +if MOZJS is None: + warn('no mozjs found (did not check native wasm support nor asm.js' + ' validation)') + + +# utilities + +# removes a file if it exists, using any and all ways of doing so +def delete_from_orbit(filename): + try: + os.unlink(filename) + except OSError: + pass + if not os.path.exists(filename): + return + try: + shutil.rmtree(filename, ignore_errors=True) + except OSError: + pass + if not os.path.exists(filename): + return + try: + import stat + os.chmod(filename, os.stat(filename).st_mode | stat.S_IWRITE) + + def remove_readonly_and_try_again(func, path, exc_info): + if not (os.stat(path).st_mode & stat.S_IWRITE): + os.chmod(path, os.stat(path).st_mode | stat.S_IWRITE) + func(path) + else: + raise + shutil.rmtree(filename, onerror=remove_readonly_and_try_again) + except OSError: + pass + + +# This is a workaround for https://bugs.python.org/issue9400 +class Py2CalledProcessError(subprocess.CalledProcessError): + def __init__(self, returncode, cmd, output=None, stderr=None): + super(Exception, self).__init__(returncode, cmd, output, stderr) + self.returncode = returncode + self.cmd = cmd + self.output = output + self.stderr = stderr + + +def run_process(cmd, check=True, input=None, capture_output=False, decode_output=True, *args, **kw): + if input and type(input) == str: + input = bytes(input, 'utf-8') + if capture_output: + kw['stdout'] = subprocess.PIPE + kw['stderr'] = subprocess.PIPE + ret = subprocess.run(cmd, check=check, input=input, *args, **kw) + if decode_output and ret.stdout is not None: + ret.stdout = ret.stdout.decode('utf-8') + if ret.stderr is not None: + ret.stderr = ret.stderr.decode('utf-8') + return ret + + +def fail_with_error(msg): + global num_failures + try: + num_failures += 1 + raise Exception(msg) + except Exception as e: + print(str(e)) + if options.abort_on_first_failure: + raise + + +def fail(actual, expected, fromfile='expected'): + diff_lines = difflib.unified_diff( + expected.split('\n'), actual.split('\n'), + fromfile=fromfile, tofile='actual') + diff_str = ''.join([a.rstrip() + '\n' for a in diff_lines])[:] + fail_with_error("incorrect output, diff:\n\n%s" % diff_str) + + +def fail_if_not_identical(actual, expected, fromfile='expected'): + if expected != actual: + fail(actual, expected, fromfile=fromfile) + + +def fail_if_not_contained(actual, expected): + if expected not in actual: + fail(actual, expected) + + +def fail_if_not_identical_to_file(actual, expected_file): + binary = expected_file.endswith(".wasm") or type(actual) == bytes + with open(expected_file, 'rb' if binary else 'r') as f: + fail_if_not_identical(actual, f.read(), fromfile=expected_file) + + +def get_test_dir(name): + """Returns the test directory located at BINARYEN_ROOT/test/[name].""" + return os.path.join(options.binaryen_test, name) + + +def get_tests(test_dir, extensions=[]): + """Returns the list of test files in a given directory. 'extensions' is a + list of file extensions. If 'extensions' is empty, returns all files. + """ + tests = [] + if not extensions: + tests += glob.glob(os.path.join(test_dir, '*')) + for ext in extensions: + tests += glob.glob(os.path.join(test_dir, '*' + ext)) + if options.test_name_filter: + tests = fnmatch.filter(tests, options.test_name_filter) + return sorted(tests) + + +if not options.interpreter: + warn('no interpreter provided (did not test spec interpreter validation)') + + +if not options.spec_tests: + options.spec_tests = get_tests(get_test_dir('spec'), ['.wast']) +else: + options.spec_tests = options.spec_tests[:] + +# 11/27/2019: We updated the spec test suite to upstream spec repo. For some +# files that started failing after this update, we added the new files to this +# skip-list and preserved old ones by renaming them to 'old_[FILENAME].wast' +# not to lose coverage. When the cause of the error is fixed or the unsupported +# construct gets support so the new test passes, we can delete the +# corresponding 'old_[FILENAME].wast' file. When you fix the new file and +# delete the old file, make sure you rename the corresponding .wast.log file in +# expected-output/ if any. +SPEC_TESTS_TO_SKIP = [ + # Stacky code / notation + 'block.wast', + 'call.wast', + 'float_exprs.wast', + 'globals.wast', + 'loop.wast', + 'nop.wast', + 'select.wast', + 'stack.wast', + 'unwind.wast', + + # Binary module + 'binary.wast', + 'binary-leb128.wast', + 'custom.wast', + + # Empty 'then' or 'else' in 'if' + 'if.wast', + 'local_set.wast', + 'store.wast', + + # No module in a file + 'token.wast', + 'utf8-custom-section-id.wast', + 'utf8-import-field.wast', + 'utf8-import-module.wast', + 'utf8-invalid-encoding.wast', + + # 'register' command + 'imports.wast', + 'linking.wast', + + # Misc. unsupported constructs + 'call_indirect.wast', # Empty (param) and (result) + 'const.wast', # Unparenthesized expression + 'data.wast', # Various unsupported (data) notations + 'elem.wast', # Unsupported 'offset' syntax in (elem) + 'exports.wast', # Multiple inlined exports for a function + 'func.wast', # Forward named type reference + 'skip-stack-guard-page.wast', # Hexadecimal style (0x..) in memory offset + + # Untriaged: We don't know the cause of the error yet + 'address.wast', # wasm2js 'assert_return' failure + 'br_if.wast', # Validation error + 'float_literals.wast', # 'assert_return' failure + 'int_literals.wast', # 'assert_return' failure + 'local_tee.wast', # Validation failure + 'memory_grow.wast', # 'assert_return' failure + 'start.wast', # Assertion failure + 'type.wast', # 'assertion_invalid' failure + 'unreachable.wast', # Validation failure + 'unreached-invalid.wast' # 'assert_invalid' failure +] +options.spec_tests = [t for t in options.spec_tests if os.path.basename(t) not + in SPEC_TESTS_TO_SKIP] + + +# check utilities + +def binary_format_check(wast, verify_final_result=True, wasm_as_args=['-g'], + binary_suffix='.fromBinary', original_wast=None): + # checks we can convert the wast to binary and back + + print(' (binary format check)') + cmd = WASM_AS + [wast, '-o', 'a.wasm', '-all'] + wasm_as_args + print(' ', ' '.join(cmd)) + if os.path.exists('a.wasm'): + os.unlink('a.wasm') + subprocess.check_call(cmd, stdout=subprocess.PIPE) + assert os.path.exists('a.wasm') + + cmd = WASM_DIS + ['a.wasm', '-o', 'ab.wast'] + print(' ', ' '.join(cmd)) + if os.path.exists('ab.wast'): + os.unlink('ab.wast') + subprocess.check_call(cmd, stdout=subprocess.PIPE) + assert os.path.exists('ab.wast') + + # make sure it is a valid wast + cmd = WASM_OPT + ['ab.wast', '-all'] + print(' ', ' '.join(cmd)) + subprocess.check_call(cmd, stdout=subprocess.PIPE) + + if verify_final_result: + actual = open('ab.wast').read() + fail_if_not_identical_to_file(actual, wast + binary_suffix) + + return 'ab.wast' + + +def minify_check(wast, verify_final_result=True): + # checks we can parse minified output + + print(' (minify check)') + cmd = WASM_OPT + [wast, '--print-minified', '-all'] + print(' ', ' '.join(cmd)) + subprocess.check_call(cmd, stdout=open('a.wast', 'w'), stderr=subprocess.PIPE) + assert os.path.exists('a.wast') + subprocess.check_call(WASM_OPT + ['a.wast', '--print-minified', '-all'], + stdout=open('b.wast', 'w'), stderr=subprocess.PIPE) + assert os.path.exists('b.wast') + if verify_final_result: + expected = open('a.wast').read() + actual = open('b.wast').read() + if actual != expected: + fail(actual, expected) + if os.path.exists('a.wast'): + os.unlink('a.wast') + if os.path.exists('b.wast'): + os.unlink('b.wast') + + +# run a check with BINARYEN_PASS_DEBUG set, to do full validation +def with_pass_debug(check): + old_pass_debug = os.environ.get('BINARYEN_PASS_DEBUG') + try: + os.environ['BINARYEN_PASS_DEBUG'] = '1' + check() + finally: + if old_pass_debug is not None: + os.environ['BINARYEN_PASS_DEBUG'] = old_pass_debug + else: + if 'BINARYEN_PASS_DEBUG' in os.environ: + del os.environ['BINARYEN_PASS_DEBUG'] + + +# checks if we are on windows, and if so logs out that a test is being skipped, +# and returns True. This is a central location for all test skipping on +# windows, so that we can easily find which tests are skipped. +def skip_if_on_windows(name): + if get_platform() == 'windows': + print('skipping test "%s" on windows' % name) + return True + return False diff --git a/binaryen/scripts/test/spectest.js b/binaryen/scripts/test/spectest.js new file mode 100644 --- /dev/null +++ b/binaryen/scripts/test/spectest.js @@ -0,0 +1,20 @@ +export function print() { + console.log(); +} +export function print_i32(arg) { + console.log(arg, ': i32'); +} +export function print_f32(arg) { + console.log(arg, ': f32'); +} +export function print_f64(arg) { + console.log(arg, ': f64'); +} +export function print_i32_f32(arg0, arg1) { + console.log(arg0, ': i32'); + console.log(arg1, ': f32'); +} +export function print_f64_f64(arg0, arg1) { + console.log(arg0, ': f64'); + console.log(arg1, ': f64'); +} diff --git a/binaryen/scripts/test/support.py b/binaryen/scripts/test/support.py new file mode 100644 --- /dev/null +++ b/binaryen/scripts/test/support.py @@ -0,0 +1,206 @@ +# Copyright 2016 WebAssembly Community Group participants +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import filecmp +import os +import shutil +import subprocess +import sys +import tempfile + + +def _open_archive(tarfile, tmp_dir): + with tempfile.TemporaryFile(mode='w+') as f: + try: + subprocess.check_call(['tar', '-xvf', tarfile], cwd=tmp_dir, stdout=f) + except Exception: + f.seek(0) + sys.stderr.write(f.read()) + raise + return os.listdir(tmp_dir) + + +def _files_same(dir1, dir2, basenames): + diff = filecmp.cmpfiles(dir1, dir2, basenames) + return 0 == len(diff[1] + diff[2]) + + +def _dirs_same(dir1, dir2, basenames): + for d in basenames: + left = os.path.join(dir1, d) + right = os.path.join(dir2, d) + if not (os.path.isdir(left) and os.path.isdir(right)): + return False + diff = filecmp.dircmp(right, right) + if 0 != len(diff.left_only + diff.right_only + diff.diff_files + + diff.common_funny + diff.funny_files): + return False + return True + + +def _move_files(dirfrom, dirto, basenames): + for f in basenames: + from_file = os.path.join(dirfrom, f) + to_file = os.path.join(dirto, f) + if os.path.isfile(to_file): + os.path.remove(to_file) + shutil.move(from_file, to_file) + + +def _move_dirs(dirfrom, dirto, basenames): + for d in basenames: + from_dir = os.path.join(dirfrom, d) + to_dir = os.path.join(dirto, d) + if os.path.isdir(to_dir): + shutil.rmtree(to_dir) + shutil.move(from_dir, to_dir) + + +def untar(tarfile, outdir): + """Returns True if untar content differs from pre-existing outdir content.""" + tmpdir = tempfile.mkdtemp() + try: + untared = _open_archive(tarfile, tmpdir) + files = [f for f in untared if os.path.isfile(os.path.join(tmpdir, f))] + dirs = [d for d in untared if os.path.isdir(os.path.join(tmpdir, d))] + assert len(files) + len(dirs) == len(untared), 'Only files and directories' + if _files_same(tmpdir, outdir, files) and _dirs_same(tmpdir, outdir, dirs): + # Nothing new or different in the tarfile. + return False + # Some or all of the files / directories are new. + _move_files(tmpdir, outdir, files) + _move_dirs(tmpdir, outdir, dirs) + return True + finally: + if os.path.isdir(tmpdir): + shutil.rmtree(tmpdir) + + +def split_wast(wastFile): + # if it's a binary, leave it as is, we can't split it + wast = None + if not wastFile.endswith('.wasm'): + try: + wast = open(wastFile, 'r').read() + except Exception: + pass + + if not wast: + return ((open(wastFile, 'rb').read(), []),) + + # .wast files can contain multiple modules, and assertions for each one. + # this splits out a wast into [(module, assertions), ..] + # we ignore module invalidity tests here. + ret = [] + + def to_end(j): + depth = 1 + while depth > 0 and j < len(wast): + if wast[j] == '"': + while 1: + j = wast.find('"', j + 1) + if wast[j - 1] == '\\': + continue + break + assert j > 0 + elif wast[j] == '(': + depth += 1 + elif wast[j] == ')': + depth -= 1 + elif wast[j] == ';' and wast[j + 1] == ';': + j = wast.find('\n', j) + j += 1 + return j + + i = 0 + while i >= 0: + start = wast.find('(', i) + if start >= 0 and wast[start + 1] == ';': + # block comment + i = wast.find(';)', start + 2) + assert i > 0, wast[start:] + i += 2 + continue + skip = wast.find(';', i) + if skip >= 0 and skip < start and skip + 1 < len(wast): + if wast[skip + 1] == ';': + i = wast.find('\n', i) + 1 + continue + if start < 0: + break + i = to_end(start + 1) + chunk = wast[start:i] + if chunk.startswith('(module'): + ret += [(chunk, [])] + elif chunk.startswith('(assert_invalid'): + continue + elif chunk.startswith(('(assert', '(invoke')): + # ret may be empty if there are some asserts before the first + # module. in that case these are asserts *without* a module, which + # are valid (they may check something that doesn't refer to a module + # in any way). + if not ret: + ret += [(None, [])] + ret[-1][1].append(chunk) + return ret + + +# write a split wast from split_wast. the wast may be binary if the original +# file was binary +def write_wast(filename, wast, asserts=[]): + if type(wast) == bytes: + assert not asserts + with open(filename, 'wb') as o: + o.write(wast) + else: + with open(filename, 'w') as o: + o.write(wast + '\n'.join(asserts)) + + +def run_command(cmd, expected_status=0, stderr=None, + expected_err=None, err_contains=False, err_ignore=None): + if expected_err is not None: + assert stderr == subprocess.PIPE or stderr is None,\ + "Can't redirect stderr if using expected_err" + stderr = subprocess.PIPE + print('executing: ', ' '.join(cmd)) + proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=stderr, universal_newlines=True, encoding='UTF-8') + out, err = proc.communicate() + code = proc.returncode + if expected_status is not None and code != expected_status: + raise Exception(('run_command failed (%s)' % code, out + str(err or ''))) + if expected_err is not None: + if err_ignore is not None: + err = "\n".join([line for line in err.split('\n') if err_ignore not in line]) + err_correct = expected_err in err if err_contains else expected_err == err + if not err_correct: + raise Exception(('run_command unexpected stderr', + "expected '%s', actual '%s'" % (expected_err, err))) + return out + + +def node_has_webassembly(cmd): + cmd = [cmd, '-e', 'process.stdout.write(typeof WebAssembly)'] + return run_command(cmd) == 'object' + + +def js_test_wrap(): + # common wrapper code for JS tests, waiting for binaryen.js to become ready + # and providing common utility used by all tests: + return ''' + binaryen.ready.then(function() { + function assert(x) { if (!x) throw Error('Test assertion failed'); } + %TEST% + }); + ''' diff --git a/binaryen/scripts/test/wasm2js.py b/binaryen/scripts/test/wasm2js.py new file mode 100644 --- /dev/null +++ b/binaryen/scripts/test/wasm2js.py @@ -0,0 +1,214 @@ +# Copyright 2016 WebAssembly Community Group participants +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import os + +from scripts.test import shared +from scripts.test import support + +tests = shared.get_tests(shared.options.binaryen_test) +# memory64 is not supported in wasm2js yet (but may be with BigInt eventually). +tests = [t for t in tests if '64.wast' not in t] +spec_tests = shared.options.spec_tests +spec_tests = [t for t in spec_tests if '.fail' not in t] +spec_tests = [t for t in spec_tests if '64.wast' not in t] +wasm2js_tests = shared.get_tests(shared.get_test_dir('wasm2js'), ['.wast']) +assert_tests = ['wasm2js.wast.asserts'] +# These tests exercise functionality not supported by wasm2js +wasm2js_blacklist = ['empty_imported_table.wast'] + + +def check_for_stale_files(): + if shared.options.test_name_filter: + return + + # TODO(sbc): Generalize and apply other test suites + all_tests = [] + for t in tests + spec_tests + wasm2js_tests: + all_tests.append(os.path.basename(os.path.splitext(t)[0])) + + all_files = os.listdir(shared.get_test_dir('wasm2js')) + for f in all_files: + prefix = f.split('.')[0] + if prefix not in all_tests: + shared.fail_with_error('orphan test output: %s' % f) + + +def test_wasm2js_output(): + for opt in (0, 1): + for t in tests + spec_tests + wasm2js_tests: + basename = os.path.basename(t) + if basename in wasm2js_blacklist: + continue + + asm = basename.replace('.wast', '.2asm.js') + expected_file = os.path.join(shared.get_test_dir('wasm2js'), asm) + if opt: + expected_file += '.opt' + + if not os.path.exists(expected_file): + continue + + print('..', os.path.basename(t)) + + all_js = [] + all_out = '' + + for module, asserts in support.split_wast(t): + support.write_wast('split.wast', module, asserts) + + # wasm2js does not yet support EH, and enabling it can reduce + # optimization opportunities + cmd = shared.WASM2JS + ['split.wast', '-all', + '--disable-exception-handling'] + if opt: + cmd += ['-O'] + if 'emscripten' in t: + cmd += ['--emscripten'] + if 'deterministic' in t: + cmd += ['--deterministic'] + js = support.run_command(cmd) + all_js.append(js) + + if not shared.NODEJS and not shared.MOZJS: + print('No JS interpreters. Skipping spec tests.') + continue + + open('a.2asm.mjs', 'w').write(js) + + cmd += ['--allow-asserts'] + js = support.run_command(cmd) + # also verify it passes pass-debug verifications + shared.with_pass_debug(lambda: support.run_command(cmd)) + + open('a.2asm.asserts.mjs', 'w').write(js) + + # verify asm.js is valid js, note that we're using --experimental-modules + # to enable ESM syntax and we're also passing a custom loader to handle the + # `spectest` and `env` modules in our tests. + if shared.NODEJS: + loader = os.path.join(shared.options.binaryen_root, 'scripts', 'test', 'node-esm-loader.mjs') + node = [shared.NODEJS, '--experimental-modules', '--no-warnings', '--loader', loader] + cmd = node[:] + cmd.append('a.2asm.mjs') + out = support.run_command(cmd) + shared.fail_if_not_identical(out, '') + cmd = node[:] + cmd.append('a.2asm.asserts.mjs') + out = support.run_command(cmd, expected_err='', err_ignore='ExperimentalWarning') + all_out += out + + shared.fail_if_not_identical_to_file(''.join(all_js), expected_file) + expected_out = os.path.join(shared.get_test_dir('spec'), 'expected-output', os.path.basename(t) + '.log') + if os.path.exists(expected_out): + expected_out = open(expected_out).read() + else: + expected_out = '' + shared.fail_if_not_identical(all_out, expected_out) + + +def test_asserts_output(): + for wasm in assert_tests: + print('..', wasm) + + asserts = os.path.basename(wasm).replace('.wast.asserts', '.asserts.js') + traps = os.path.basename(wasm).replace('.wast.asserts', '.traps.js') + asserts_expected_file = os.path.join(shared.options.binaryen_test, asserts) + traps_expected_file = os.path.join(shared.options.binaryen_test, traps) + + wasm = os.path.join(shared.get_test_dir('wasm2js'), wasm) + cmd = shared.WASM2JS + [wasm, '--allow-asserts', '-all', + '--disable-exception-handling'] + out = support.run_command(cmd) + shared.fail_if_not_identical_to_file(out, asserts_expected_file) + + cmd += ['--pedantic'] + out = support.run_command(cmd) + shared.fail_if_not_identical_to_file(out, traps_expected_file) + + +def test_wasm2js(): + print('\n[ checking wasm2js testcases... ]\n') + check_for_stale_files() + if shared.skip_if_on_windows('wasm2js'): + return + test_wasm2js_output() + test_asserts_output() + + +def update_wasm2js_tests(): + print('\n[ checking wasm2js ]\n') + + for opt in (0, 1): + for wasm in tests + spec_tests + wasm2js_tests: + if not wasm.endswith('.wast'): + continue + + if os.path.basename(wasm) in wasm2js_blacklist: + continue + + asm = os.path.basename(wasm).replace('.wast', '.2asm.js') + expected_file = os.path.join(shared.get_test_dir('wasm2js'), asm) + if opt: + expected_file += '.opt' + + # we run wasm2js on tests and spec tests only if the output + # exists - only some work so far. the tests in extra are in + # the test/wasm2js dir and so are specific to wasm2js, and + # we run all of those. + if wasm not in wasm2js_tests and not os.path.exists(expected_file): + continue + + print('..', wasm) + + t = os.path.join(shared.options.binaryen_test, wasm) + + all_out = [] + + for module, asserts in support.split_wast(t): + support.write_wast('split.wast', module, asserts) + + # wasm2js does not yet support EH, and enable it can reduce + # optimization opportunities + cmd = shared.WASM2JS + ['split.wast', '-all', + '--disable-exception-handling'] + if opt: + cmd += ['-O'] + if 'emscripten' in wasm: + cmd += ['--emscripten'] + if 'deterministic' in t: + cmd += ['--deterministic'] + out = support.run_command(cmd) + all_out.append(out) + + with open(expected_file, 'w') as o: + o.write(''.join(all_out)) + + for wasm in assert_tests: + print('..', wasm) + + asserts = os.path.basename(wasm).replace('.wast.asserts', '.asserts.js') + traps = os.path.basename(wasm).replace('.wast.asserts', '.traps.js') + asserts_expected_file = os.path.join(shared.options.binaryen_test, asserts) + traps_expected_file = os.path.join(shared.options.binaryen_test, traps) + + cmd = shared.WASM2JS + [os.path.join(shared.get_test_dir('wasm2js'), wasm), '--allow-asserts', '-all', '--disable-exception-handling'] + out = support.run_command(cmd) + with open(asserts_expected_file, 'w') as o: + o.write(out) + + cmd += ['--pedantic'] + out = support.run_command(cmd) + with open(traps_expected_file, 'w') as o: + o.write(out) diff --git a/binaryen/scripts/test/wasm_opt.py b/binaryen/scripts/test/wasm_opt.py new file mode 100644 --- /dev/null +++ b/binaryen/scripts/test/wasm_opt.py @@ -0,0 +1,238 @@ +# Copyright 2016 WebAssembly Community Group participants +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import os +import shutil +import subprocess + +from . import shared +from . import support + + +def test_wasm_opt(): + print('\n[ checking wasm-opt -o notation... ]\n') + + for extra_args in [[], ['--no-validation']]: + wast = os.path.join(shared.options.binaryen_test, 'hello_world.wat') + shared.delete_from_orbit('a.wat') + out = 'a.wat' + cmd = shared.WASM_OPT + [wast, '-o', out, '-S'] + extra_args + support.run_command(cmd) + shared.fail_if_not_identical_to_file(open(out).read(), wast) + + print('\n[ checking wasm-opt binary reading/writing... ]\n') + + shutil.copyfile(os.path.join(shared.options.binaryen_test, 'hello_world.wat'), 'a.wat') + shared.delete_from_orbit('a.wasm') + shared.delete_from_orbit('b.wast') + support.run_command(shared.WASM_OPT + ['a.wat', '-o', 'a.wasm']) + assert open('a.wasm', 'rb').read()[0] == 0, 'we emit binary by default' + support.run_command(shared.WASM_OPT + ['a.wasm', '-o', 'b.wast', '-S']) + assert open('b.wast', 'rb').read()[0] != 0, 'we emit text with -S' + + print('\n[ checking wasm-opt passes... ]\n') + + for t in shared.get_tests(shared.get_test_dir('passes'), ['.wast', '.wasm']): + print('..', os.path.basename(t)) + # windows has some failures that need to be investigated: + # * ttf tests have different outputs - order of execution of params? + # * dwarf tests print windows slashes instead of unix + if ('translate-to-fuzz' in t or 'dwarf' in t) and \ + shared.skip_if_on_windows('fuzz translation tests'): + continue + binary = '.wasm' in t + base = os.path.basename(t).replace('.wast', '').replace('.wasm', '') + passname = base + passes_file = os.path.join(shared.get_test_dir('passes'), passname + '.passes') + if os.path.exists(passes_file): + passname = open(passes_file).read().strip() + opts = [('--' + p if not p.startswith('O') and p != 'g' else '-' + p) for p in passname.split('_')] + actual = '' + for module, asserts in support.split_wast(t): + assert len(asserts) == 0 + support.write_wast('split.wast', module) + cmd = shared.WASM_OPT + opts + ['split.wast'] + if 'noprint' not in t: + cmd.append('--print') + curr = support.run_command(cmd) + actual += curr + # also check debug mode output is valid + debugged = support.run_command(cmd + ['--debug'], stderr=subprocess.PIPE) + shared.fail_if_not_contained(actual, debugged) + + # also check pass-debug mode + def check(): + pass_debug = support.run_command(cmd) + shared.fail_if_not_identical(curr, pass_debug) + shared.with_pass_debug(check) + + expected_file = os.path.join(shared.get_test_dir('passes'), base + ('.bin' if binary else '') + '.txt') + shared.fail_if_not_identical_to_file(actual, expected_file) + + if 'emit-js-wrapper' in t: + with open('a.js') as actual: + shared.fail_if_not_identical_to_file(actual.read(), t + '.js') + if 'emit-spec-wrapper' in t: + with open('a.wat') as actual: + shared.fail_if_not_identical_to_file(actual.read(), t + '.wat') + + print('\n[ checking wasm-opt parsing & printing... ]\n') + + for t in shared.get_tests(shared.get_test_dir('print'), ['.wast']): + print('..', os.path.basename(t)) + wasm = os.path.basename(t).replace('.wast', '') + cmd = shared.WASM_OPT + [t, '--print', '-all'] + print(' ', ' '.join(cmd)) + actual, err = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True).communicate() + expected_file = os.path.join(shared.get_test_dir('print'), wasm + '.txt') + shared.fail_if_not_identical_to_file(actual, expected_file) + cmd = shared.WASM_OPT + [os.path.join(shared.get_test_dir('print'), t), '--print-minified', '-all'] + print(' ', ' '.join(cmd)) + actual, err = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True).communicate() + shared.fail_if_not_identical(actual.strip(), open(os.path.join(shared.get_test_dir('print'), wasm + '.minified.txt')).read().strip()) + + print('\n[ checking wasm-opt testcases... ]\n') + + for t in shared.get_tests(shared.options.binaryen_test, ['.wast']): + print('..', os.path.basename(t)) + f = t + '.from-wast' + cmd = shared.WASM_OPT + [t, '--print', '-all'] + actual = support.run_command(cmd) + actual = actual.replace('printing before:\n', '') + + shared.fail_if_not_identical_to_file(actual, f) + + # FIXME Remove this condition after nullref is implemented in V8 + if 'reference-types.wast' not in t: + shared.binary_format_check(t, wasm_as_args=['-g']) # test with debuginfo + shared.binary_format_check(t, wasm_as_args=[], binary_suffix='.fromBinary.noDebugInfo') # test without debuginfo + + shared.minify_check(t) + + print('\n[ checking wasm-opt debugInfo read-write... ]\n') + + for t in shared.get_tests(shared.options.binaryen_test, ['.fromasm']): + if 'debugInfo' not in t: + continue + print('..', os.path.basename(t)) + f = t + '.read-written' + support.run_command(shared.WASM_AS + [t, '--source-map=a.map', '-o', 'a.wasm', '-g']) + support.run_command(shared.WASM_OPT + ['a.wasm', '--input-source-map=a.map', '-o', 'b.wasm', '--output-source-map=b.map', '-g']) + actual = support.run_command(shared.WASM_DIS + ['b.wasm', '--source-map=b.map']) + shared.fail_if_not_identical_to_file(actual, f) + + +def update_wasm_opt_tests(): + print('\n[ checking wasm-opt -o notation... ]\n') + wast = os.path.join(shared.options.binaryen_test, 'hello_world.wat') + cmd = shared.WASM_OPT + [wast, '-o', 'a.wast', '-S'] + support.run_command(cmd) + open(wast, 'w').write(open('a.wast').read()) + + print('\n[ checking wasm-opt parsing & printing... ]\n') + for t in shared.get_tests(shared.get_test_dir('print'), ['.wast']): + print('..', os.path.basename(t)) + wasm = t.replace('.wast', '') + cmd = shared.WASM_OPT + [t, '--print', '-all'] + print(' ', ' '.join(cmd)) + actual = subprocess.check_output(cmd) + print(cmd, actual) + with open(wasm + '.txt', 'wb') as o: + o.write(actual) + cmd = shared.WASM_OPT + [t, '--print-minified', '-all'] + print(' ', ' '.join(cmd)) + actual = subprocess.check_output(cmd) + with open(wasm + '.minified.txt', 'wb') as o: + o.write(actual) + + print('\n[ checking wasm-opt passes... ]\n') + for t in shared.get_tests(shared.get_test_dir('passes'), ['.wast', '.wasm']): + print('..', os.path.basename(t)) + # windows has some failures that need to be investigated: + # * ttf tests have different outputs - order of execution of params? + # * dwarf tests print windows slashes instead of unix + if ('translate-to-fuzz' in t or 'dwarf' in t) and \ + shared.skip_if_on_windows('fuzz translation tests'): + continue + binary = t.endswith('.wasm') + base = os.path.basename(t).replace('.wast', '').replace('.wasm', '') + passname = base + passes_file = os.path.join(shared.get_test_dir('passes'), passname + '.passes') + if os.path.exists(passes_file): + passname = open(passes_file).read().strip() + opts = [('--' + p if not p.startswith('O') and p != 'g' else '-' + p) for p in passname.split('_')] + actual = '' + for module, asserts in support.split_wast(t): + assert len(asserts) == 0 + support.write_wast('split.wast', module) + cmd = shared.WASM_OPT + opts + ['split.wast'] + if 'noprint' not in t: + cmd.append('--print') + actual += support.run_command(cmd) + with open(os.path.join(shared.options.binaryen_test, 'passes', base + ('.bin' if binary else '') + '.txt'), 'w') as o: + o.write(actual) + if 'emit-js-wrapper' in t: + with open('a.js') as i: + with open(t + '.js', 'w') as o: + o.write(i.read()) + if 'emit-spec-wrapper' in t: + with open('a.wat') as i: + with open(t + '.wat', 'w') as o: + o.write(i.read()) + + print('\n[ checking wasm-opt testcases... ]\n') + for t in shared.get_tests(shared.options.binaryen_test, ['.wast']): + print('..', os.path.basename(t)) + f = t + '.from-wast' + cmd = shared.WASM_OPT + [t, '--print', '-all'] + actual = support.run_command(cmd) + actual = actual.replace('printing before:\n', '') + open(f, 'w').write(actual) + + print('\n[ checking wasm-opt debugInfo read-write... ]\n') + for t in shared.get_tests(shared.options.binaryen_test, ['.fromasm']): + if 'debugInfo' not in t: + continue + print('..', os.path.basename(t)) + f = t + '.read-written' + support.run_command(shared.WASM_AS + [t, '--source-map=a.map', '-o', 'a.wasm', '-g']) + support.run_command(shared.WASM_OPT + ['a.wasm', '--input-source-map=a.map', '-o', 'b.wasm', '--output-source-map=b.map', '-g']) + actual = support.run_command(shared.WASM_DIS + ['b.wasm', '--source-map=b.map']) + open(f, 'w').write(actual) + + print('\n[ checking binary format testcases... ]\n') + for wast in shared.get_tests(shared.options.binaryen_test, ['.wast']): + for debug_info in [0, 1]: + cmd = shared.WASM_AS + [wast, '-o', 'a.wasm', '-all'] + if debug_info: + cmd += ['-g'] + print(' '.join(cmd)) + if os.path.exists('a.wasm'): + os.unlink('a.wasm') + subprocess.check_call(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE) + assert os.path.exists('a.wasm') + + cmd = shared.WASM_DIS + ['a.wasm', '-o', 'a.wast'] + print(' '.join(cmd)) + if os.path.exists('a.wast'): + os.unlink('a.wast') + subprocess.check_call(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE) + assert os.path.exists('a.wast') + actual = open('a.wast').read() + binary_file = wast + '.fromBinary' + if not debug_info: + binary_file += '.noDebugInfo' + with open(binary_file, 'w') as o: + print('writey', binary_file) + o.write(actual) diff --git a/binaryen/scripts/validation_shell.js b/binaryen/scripts/validation_shell.js new file mode 100644 --- /dev/null +++ b/binaryen/scripts/validation_shell.js @@ -0,0 +1,28 @@ +// Test a file is valid, by just loading it. + +// Shell integration. +if (typeof console === 'undefined') { + console = { log: print }; +} +var binary; +if (typeof process === 'object' && typeof require === 'function' /* node.js detection */) { + var args = process.argv.slice(2); + binary = require('fs').readFileSync(args[0]); + if (!binary.buffer) binary = new Uint8Array(binary); +} else { + var args; + if (typeof scriptArgs != 'undefined') { + args = scriptArgs; + } else if (typeof arguments != 'undefined') { + args = arguments; + } + if (typeof readbuffer === 'function') { + binary = new Uint8Array(readbuffer(args[0])); + } else { + binary = read(args[0], 'binary'); + } +} + +// Test the wasm for validity by compiling it. +new WebAssembly.Module(binary); + diff --git a/binaryen/scripts/wasm2js.js b/binaryen/scripts/wasm2js.js new file mode 100644 --- /dev/null +++ b/binaryen/scripts/wasm2js.js @@ -0,0 +1,204 @@ +// wasm2js.js - enough of a polyfill for the WebAssembly object so that we can load +// wasm2js code that way. Similar to the same file in emscripten, but tailored for +// fuzzing purposes here. + +var WebAssembly = { + Memory: function(opts) { + return { + buffer: new ArrayBuffer(opts['initial'] * 64 * 1024), + }; + }, + + Table: function(opts) { + var ret = new Array(opts['initial']); + ret.grow = function(by) { + ret.push(null); + }; + ret.set = function(i, func) { + ret[i] = func; + }; + ret.get = function(i) { + return ret[i]; + }; + return ret; + }, + + Module: function(binary) { + // TODO: use the binary and info somehow - right now the wasm2js output is embedded in + // the main JS + return {}; + }, + + Instance: function(module, info) { + // TODO: use the module and info somehow - right now the wasm2js output is embedded in + // the main JS + var decodeBase64 = typeof atob === 'function' ? atob : function (input) { + var keyStr = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/='; + + var output = ''; + var chr1, chr2, chr3; + var enc1, enc2, enc3, enc4; + var i = 0; + // remove all characters that are not A-Z, a-z, 0-9, +, /, or = + input = input.replace(/[^A-Za-z0-9\+\/\=]/g, ''); + do { + enc1 = keyStr.indexOf(input.charAt(i++)); + enc2 = keyStr.indexOf(input.charAt(i++)); + enc3 = keyStr.indexOf(input.charAt(i++)); + enc4 = keyStr.indexOf(input.charAt(i++)); + + chr1 = (enc1 << 2) | (enc2 >> 4); + chr2 = ((enc2 & 15) << 4) | (enc3 >> 2); + chr3 = ((enc3 & 3) << 6) | enc4; + + output = output + String.fromCharCode(chr1); + + if (enc3 !== 64) { + output = output + String.fromCharCode(chr2); + } + if (enc4 !== 64) { + output = output + String.fromCharCode(chr3); + } + } while (i < input.length); + return output; + }; + var atob = decodeBase64; + // Additional imports + asmLibraryArg['__tempMemory__'] = 0; // risky! + // This will be replaced by the actual wasm2js code. + var exports = instantiate(asmLibraryArg, wasmMemory); + return { + 'exports': exports + }; + }, + + instantiate: function(binary, info) { + return { + then: function(ok, err) { + ok({ + 'instance': new WebAssembly.Instance(new WebAssembly.Module(binary, info)) + }); + } + }; + } +}; + +var tempRet0 = 0; + +var asmLibraryArg = { + log_i32: function(x) { + console.log('[LoggingExternalInterface logging ' + literal(x, 'i32') + ']'); + }, + log_i64: function(x, h) { + console.log('[LoggingExternalInterface logging ' + literal(x, 'i32') + ' ' + literal(h, 'i32') + ']'); + }, + log_f32: function(x) { + console.log('[LoggingExternalInterface logging ' + literal(x, 'f64') + ']'); + }, + log_f64: function(x) { + console.log('[LoggingExternalInterface logging ' + literal(x, 'f64') + ']'); + }, + log_execution: function(loc) { + console.log('log_execution ' + loc); + }, + setTempRet0: function(x) { + tempRet0 = x; + }, + getTempRet0: function() { + return x; + }, + get_i32: function(loc, index, value) { + console.log('get_i32 ' + [loc, index, value]); + return value; + }, + get_i64: function(loc, index, low, high) { + console.log('get_i64 ' + [loc, index, low, high]); + asmLibraryArg['setTempRet0'](high); + return low; + }, + get_f32: function(loc, index, value) { + console.log('get_f32 ' + [loc, index, value]); + return value; + }, + get_f64: function(loc, index, value) { + console.log('get_f64 ' + [loc, index, value]); + return value; + }, + get_externref: function(loc, index, value) { + console.log('get_externref ' + [loc, index, value]); + return value; + }, + get_exnref: function(loc, index, value) { + console.log('get_exnref ' + [loc, index, value]); + return value; + }, + set_i32: function(loc, index, value) { + console.log('set_i32 ' + [loc, index, value]); + return value; + }, + set_i64: function(loc, index, low, high) { + console.log('set_i64 ' + [loc, index, low, high]); + asmLibraryArg['setTempRet0'](high); + return low; + }, + set_f32: function(loc, index, value) { + console.log('set_f32 ' + [loc, index, value]); + return value; + }, + set_f64: function(loc, index, value) { + console.log('set_f64 ' + [loc, index, value]); + return value; + }, + set_externref: function(loc, index, value) { + console.log('set_externref ' + [loc, index, value]); + return value; + }, + set_exnref: function(loc, index, value) { + console.log('set_exnref ' + [loc, index, value]); + return value; + }, + load_ptr: function(loc, bytes, offset, ptr) { + console.log('load_ptr ' + [loc, bytes, offset, ptr]); + return ptr; + }, + load_val_i32: function(loc, value) { + console.log('load_val_i32 ' + [loc, value]); + return value; + }, + load_val_i64: function(loc, low, high) { + console.log('load_val_i64 ' + [loc, low, high]); + asmLibraryArg['setTempRet0'](high); + return low; + }, + load_val_f32: function(loc, value) { + console.log('loaload_val_i32d_ptr ' + [loc, value]); + return value; + }, + load_val_f64: function(loc, value) { + console.log('load_val_f64 ' + [loc, value]); + return value; + }, + store_ptr: function(loc, bytes, offset, ptr) { + console.log('store_ptr ' + [loc, bytes, offset, ptr]); + return ptr; + }, + store_val_i32: function(loc, value) { + console.log('store_val_i32 ' + [loc, value]); + return value; + }, + store_val_i64: function(loc, low, high) { + console.log('store_val_i64 ' + [loc, low, high]); + asmLibraryArg['setTempRet0'](high); + return low; + }, + store_val_f32: function(loc, value) { + console.log('loastore_val_i32d_ptr ' + [loc, value]); + return value; + }, + store_val_f64: function(loc, value) { + console.log('store_val_f64 ' + [loc, value]); + return value; + }, +}; + +var wasmMemory = new WebAssembly.Memory({ initial: 1 }); diff --git a/binaryen/src/abi/abi.h b/binaryen/src/abi/abi.h new file mode 100644 --- /dev/null +++ b/binaryen/src/abi/abi.h @@ -0,0 +1,33 @@ +/* + * Copyright 2017 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef wasm_abi_abi_h +#define wasm_abi_abi_h + +#include "wasm.h" + +namespace wasm { + +namespace ABI { + +// The pointer type. Will need to update this for wasm64 +const static Type PointerType = Type::i32; + +} // namespace ABI + +} // namespace wasm + +#endif // wasm_abi_abi_h diff --git a/binaryen/src/abi/js.h b/binaryen/src/abi/js.h new file mode 100644 --- /dev/null +++ b/binaryen/src/abi/js.h @@ -0,0 +1,110 @@ +/* + * Copyright 2018 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef wasm_abi_abi_h +#define wasm_abi_abi_h + +#include "asmjs/shared-constants.h" +#include "wasm.h" + +namespace wasm { + +namespace ABI { + +enum class LegalizationLevel { Full = 0, Minimal = 1 }; + +inline std::string getLegalizationPass(LegalizationLevel level) { + if (level == LegalizationLevel::Full) { + return "legalize-js-interface"; + } else { + return "legalize-js-interface-minimally"; + } +} + +namespace wasm2js { + +extern cashew::IString SCRATCH_LOAD_I32; +extern cashew::IString SCRATCH_STORE_I32; +extern cashew::IString SCRATCH_LOAD_F32; +extern cashew::IString SCRATCH_STORE_F32; +extern cashew::IString SCRATCH_LOAD_F64; +extern cashew::IString SCRATCH_STORE_F64; +extern cashew::IString MEMORY_INIT; +extern cashew::IString MEMORY_FILL; +extern cashew::IString MEMORY_COPY; +extern cashew::IString DATA_DROP; +extern cashew::IString ATOMIC_WAIT_I32; +extern cashew::IString ATOMIC_RMW_I64; +extern cashew::IString GET_STASHED_BITS; + +// The wasm2js helpers let us do things that can't be done without special help, +// like read and write to scratch memory for purposes of implementing things +// like reinterpret, etc. +// The optional "specific" parameter is a specific function we want. If not +// provided, we create them all. +inline void ensureHelpers(Module* wasm, + cashew::IString specific = cashew::IString()) { + auto ensureImport = [&](Name name, Type params, Type results) { + if (wasm->getFunctionOrNull(name)) { + return; + } + if (specific.is() && name != specific) { + return; + } + auto func = make_unique(); + func->name = name; + func->sig = Signature(params, results); + func->module = ENV; + func->base = name; + wasm->addFunction(std::move(func)); + }; + + ensureImport(SCRATCH_LOAD_I32, {Type::i32}, Type::i32); + ensureImport(SCRATCH_STORE_I32, {Type::i32, Type::i32}, Type::none); + ensureImport(SCRATCH_LOAD_F32, {}, Type::f32); + ensureImport(SCRATCH_STORE_F32, {Type::f32}, Type::none); + ensureImport(SCRATCH_LOAD_F64, {}, Type::f64); + ensureImport(SCRATCH_STORE_F64, {Type::f64}, Type::none); + ensureImport( + MEMORY_INIT, {Type::i32, Type::i32, Type::i32, Type::i32}, Type::none); + ensureImport(MEMORY_FILL, {Type::i32, Type::i32, Type::i32}, Type::none); + ensureImport(MEMORY_COPY, {Type::i32, Type::i32, Type::i32}, Type::none); + ensureImport(DATA_DROP, {Type::i32}, Type::none); + ensureImport( + ATOMIC_WAIT_I32, {Type::i32, Type::i32, Type::i32, Type::i32}, Type::i32); + ensureImport( + ATOMIC_RMW_I64, + {Type::i32, Type::i32, Type::i32, Type::i32, Type::i32, Type::i32}, + Type::i32); + ensureImport(GET_STASHED_BITS, {}, Type::i32); +} + +inline bool isHelper(cashew::IString name) { + return name == SCRATCH_LOAD_I32 || name == SCRATCH_STORE_I32 || + name == SCRATCH_LOAD_F32 || name == SCRATCH_STORE_F32 || + name == SCRATCH_LOAD_F64 || name == SCRATCH_STORE_F64 || + name == ATOMIC_WAIT_I32 || name == MEMORY_INIT || + name == MEMORY_FILL || name == MEMORY_COPY || name == DATA_DROP || + name == ATOMIC_RMW_I64 || name == GET_STASHED_BITS; +} + +} // namespace wasm2js + +} // namespace ABI + +} // namespace wasm + +#endif // wasm_abi_abi_h diff --git a/binaryen/src/abi/stack.h b/binaryen/src/abi/stack.h new file mode 100644 --- /dev/null +++ b/binaryen/src/abi/stack.h @@ -0,0 +1,144 @@ +/* + * Copyright 2017 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef wasm_abi_stack_h +#define wasm_abi_stack_h + +#include "abi.h" +#include "asmjs/shared-constants.h" +#include "ir/find_all.h" +#include "ir/global-utils.h" +#include "shared-constants.h" +#include "wasm-builder.h" +#include "wasm.h" + +namespace wasm { + +namespace ABI { + +enum { StackAlign = 16 }; + +inline Index stackAlign(Index size) { + return (size + StackAlign - 1) & -StackAlign; +} + +// Allocate some space on the stack, and assign it to a local. +// The local will have the same constant value in all the function, so you can +// just local.get it anywhere there. +// +// FIXME: This function assumes that the stack grows upward, per the convention +// used by fastcomp. The stack grows downward when using the WASM backend. + +inline void +getStackSpace(Index local, Function* func, Index size, Module& wasm) { + // Attempt to locate the stack pointer by recognizing code idioms + // used by Emscripten. First, look for a global initialized to an + // imported variable named "STACKTOP" in environment "env". + auto* stackPointer = + GlobalUtils::getGlobalInitializedToImport(wasm, ENV, "STACKTOP"); + // Starting with Emscripten 1.38.24, the stack pointer variable is + // initialized with a literal constant, eliminating the import that + // we used to locate the stack pointer by name. We must match a more + // complicated idiom, expecting to see the module structured as follows: + // + //(module + // ... + // (export "stackSave" (func $stackSave)) + // ... + // (func $stackSave (; 410 ;) (; has Stack IR ;) (result i32) + // (global.get $STACKTOP) + // ) + // ... + //) + if (!stackPointer) { + auto* stackSaveFunctionExport = wasm.getExportOrNull("stackSave"); + if (stackSaveFunctionExport && + stackSaveFunctionExport->kind == ExternalKind::Function) { + auto* stackSaveFunction = + wasm.getFunction(stackSaveFunctionExport->value); + assert(!stackSaveFunction->imported()); + auto* globalGet = stackSaveFunction->body->dynCast(); + if (globalGet) { + stackPointer = wasm.getGlobal(globalGet->name); + } + } + } + if (!stackPointer) { + Fatal() << "getStackSpace: failed to find the stack pointer"; + } + // align the size + size = stackAlign(size); + // TODO: find existing stack usage, and add on top of that - carefully + Builder builder(wasm); + auto* block = builder.makeBlock(); + block->list.push_back(builder.makeLocalSet( + local, builder.makeGlobalGet(stackPointer->name, PointerType))); + // TODO: add stack max check + Expression* added; + if (PointerType == Type::i32) { + added = builder.makeBinary(AddInt32, + builder.makeLocalGet(local, PointerType), + builder.makeConst(int32_t(size))); + } else { + WASM_UNREACHABLE("unhandled PointerType"); + } + block->list.push_back(builder.makeGlobalSet(stackPointer->name, added)); + auto makeStackRestore = [&]() { + return builder.makeGlobalSet(stackPointer->name, + builder.makeLocalGet(local, PointerType)); + }; + // add stack restores to the returns + FindAllPointers finder(func->body); + for (auto** ptr : finder.list) { + auto* ret = (*ptr)->cast(); + if (ret->value && ret->value->type != Type::unreachable) { + // handle the returned value + auto* block = builder.makeBlock(); + auto temp = builder.addVar(func, ret->value->type); + block->list.push_back(builder.makeLocalSet(temp, ret->value)); + block->list.push_back(makeStackRestore()); + block->list.push_back( + builder.makeReturn(builder.makeLocalGet(temp, ret->value->type))); + block->finalize(); + *ptr = block; + } else { + // restore, then return + *ptr = builder.makeSequence(makeStackRestore(), ret); + } + } + // add stack restores to the body + if (func->body->type == Type::none) { + block->list.push_back(func->body); + block->list.push_back(makeStackRestore()); + } else if (func->body->type == Type::unreachable) { + block->list.push_back(func->body); + // no need to restore the old stack value, we're gone anyhow + } else { + // save the return value + auto temp = builder.addVar(func, func->sig.results); + block->list.push_back(builder.makeLocalSet(temp, func->body)); + block->list.push_back(makeStackRestore()); + block->list.push_back(builder.makeLocalGet(temp, func->sig.results)); + } + block->finalize(); + func->body = block; +} + +} // namespace ABI + +} // namespace wasm + +#endif // wasm_abi_stack_h diff --git a/binaryen/src/abi/wasm-object.h b/binaryen/src/abi/wasm-object.h new file mode 100644 --- /dev/null +++ b/binaryen/src/abi/wasm-object.h @@ -0,0 +1,40 @@ +/* + * Copyright 2018 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// Contains definitions used for wasm object files. +// See: https://github.com/WebAssembly/tool-conventions/blob/master/Linking.md +// + +#ifndef wasm_abi_wasm_object_h +#define wasm_abi_wasm_object_h + +namespace wasm { + +namespace ABI { +enum LinkType : unsigned { + WASM_STACK_POINTER = 0x1, + WASM_SYMBOL_INFO = 0x2, + WASM_DATA_SIZE = 0x3, + WASM_DATA_ALIGNMENT = 0x4, + WASM_SEGMENT_INFO = 0x5, + WASM_INIT_FUNCS = 0x6, +}; +} // namespace ABI + +} // namespace wasm + +#endif // wasm_abi_wasm_object_h diff --git a/binaryen/src/asm_v_wasm.h b/binaryen/src/asm_v_wasm.h new file mode 100644 --- /dev/null +++ b/binaryen/src/asm_v_wasm.h @@ -0,0 +1,71 @@ +/* + * Copyright 2015 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef wasm_asm_v_wasm_h +#define wasm_asm_v_wasm_h + +#include "emscripten-optimizer/optimizer.h" +#include "mixed_arena.h" +#include "wasm.h" + +namespace wasm { + +Type asmToWasmType(AsmType asmType); + +AsmType wasmToAsmType(Type type); + +char getSig(Type type); +std::string getSig(Function* func); +std::string getSig(Type results, Type params); + +template::value>::type* = + nullptr> +std::string getSig(T* call) { + std::string ret; + ret += getSig(call->type); + for (auto operand : call->operands) { + ret += getSig(operand->type); + } + return ret; +} + +template +std::string getSig(Type result, const ListType& operands) { + std::string ret; + ret += getSig(result); + for (auto operand : operands) { + ret += getSig(operand->type); + } + return ret; +} + +template +std::string getSigFromStructs(Type result, const ListType& operands) { + std::string ret; + ret += getSig(result); + for (auto operand : operands) { + ret += getSig(operand.type); + } + return ret; +} + +// converts an f32 to an f64 if necessary +Expression* ensureDouble(Expression* expr, MixedArena& allocator); + +} // namespace wasm + +#endif // wasm_asm_v_wasm_h diff --git a/binaryen/src/asmjs/CMakeLists.txt b/binaryen/src/asmjs/CMakeLists.txt new file mode 100644 --- /dev/null +++ b/binaryen/src/asmjs/CMakeLists.txt @@ -0,0 +1,8 @@ +FILE(GLOB asmjs_HEADERS *.h) +set(asmjs_SOURCES + asm_v_wasm.cpp + asmangle.cpp + shared-constants.cpp + ${asmjs_HEADERS} +) +add_library(asmjs OBJECT ${asmjs_SOURCES}) diff --git a/binaryen/src/asmjs/asm_v_wasm.cpp b/binaryen/src/asmjs/asm_v_wasm.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/asmjs/asm_v_wasm.cpp @@ -0,0 +1,131 @@ +/* + * Copyright 2015 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "asm_v_wasm.h" +#include "wasm.h" + +namespace wasm { + +Type asmToWasmType(AsmType asmType) { + switch (asmType) { + case ASM_INT: + return Type::i32; + case ASM_DOUBLE: + return Type::f64; + case ASM_FLOAT: + return Type::f32; + case ASM_INT64: + return Type::i64; + case ASM_NONE: + return Type::none; + case ASM_FLOAT32X4: + case ASM_FLOAT64X2: + case ASM_INT8X16: + case ASM_INT16X8: + case ASM_INT32X4: + return Type::v128; + } + WASM_UNREACHABLE("invalid type"); +} + +AsmType wasmToAsmType(Type type) { + TODO_SINGLE_COMPOUND(type); + switch (type.getBasic()) { + case Type::i32: + return ASM_INT; + case Type::f32: + return ASM_FLOAT; + case Type::f64: + return ASM_DOUBLE; + case Type::i64: + return ASM_INT64; + case Type::v128: + assert(false && "v128 not implemented yet"); + case Type::funcref: + case Type::externref: + case Type::exnref: + case Type::anyref: + case Type::eqref: + case Type::i31ref: + assert(false && "reference types are not supported by asm2wasm"); + case Type::none: + return ASM_NONE; + case Type::unreachable: + WASM_UNREACHABLE("invalid type"); + } + WASM_UNREACHABLE("invalid type"); +} + +char getSig(Type type) { + TODO_SINGLE_COMPOUND(type); + switch (type.getBasic()) { + case Type::i32: + return 'i'; + case Type::i64: + return 'j'; + case Type::f32: + return 'f'; + case Type::f64: + return 'd'; + case Type::v128: + return 'V'; + case Type::funcref: + return 'F'; + case Type::externref: + return 'X'; + case Type::exnref: + return 'E'; + case Type::anyref: + return 'A'; + case Type::eqref: + return 'Q'; + case Type::i31ref: + return 'I'; + case Type::none: + return 'v'; + case Type::unreachable: + WASM_UNREACHABLE("invalid type"); + } + WASM_UNREACHABLE("invalid type"); +} + +std::string getSig(Function* func) { + return getSig(func->sig.results, func->sig.params); +} + +std::string getSig(Type results, Type params) { + assert(!results.isTuple()); + std::string sig; + sig += getSig(results); + for (const auto& param : params) { + sig += getSig(param); + } + return sig; +} + +Expression* ensureDouble(Expression* expr, MixedArena& allocator) { + if (expr->type == Type::f32) { + auto conv = allocator.alloc(); + conv->op = PromoteFloat32; + conv->value = expr; + conv->type = Type::f64; + return conv; + } + assert(expr->type == Type::f64); + return expr; +} + +} // namespace wasm diff --git a/binaryen/src/asmjs/asmangle.cpp b/binaryen/src/asmjs/asmangle.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/asmjs/asmangle.cpp @@ -0,0 +1,204 @@ +/* + * Copyright 2018 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "asmjs/asmangle.h" +#include + +namespace wasm { + +std::string asmangle(std::string name) { + // Wasm allows empty names as exports etc., but JS doesn't allow such + // identifiers. + if (name.empty()) { + name = "$"; + } + + bool mightBeKeyword = true; + size_t i = 1; + + assert(!name.empty()); + + // Names must start with a character, $ or _ + switch (auto ch = name[0]) { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': { + name = "$" + name; + i = 2; + goto notKeyword; + } + notKeyword: + case '$': + case '_': { + mightBeKeyword = false; + break; + } + default: { + if (!(ch >= 'a' && ch <= 'z') && !(ch >= 'A' && ch <= 'Z')) { + name = "$" + name.substr(1); + mightBeKeyword = false; + } + } + } + + // Names must contain only characters, digits, $ or _ + size_t len = name.length(); + for (; i < len; ++i) { + switch (char ch = name[i]) { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + case '$': + case '_': { + mightBeKeyword = false; + break; + } + default: { + if (!(ch >= 'a' && ch <= 'z') && !(ch >= 'A' && ch <= 'Z')) { + name = name.substr(0, i) + "_" + name.substr(i + 1); + mightBeKeyword = false; + } + } + } + } + + // Names must not collide with keywords + if (mightBeKeyword && len >= 2 && len <= 10) { + switch (name[0]) { + case 'a': { + if (name == "arguments") { + goto mangleKeyword; + } + break; + } + case 'b': { + if (name == "break") { + goto mangleKeyword; + } + break; + } + case 'c': { + if (name == "case" || name == "continue" || name == "catch" || + name == "const" || name == "class") { + goto mangleKeyword; + } + break; + } + case 'd': { + if (name == "do" || name == "default" || name == "debugger") { + goto mangleKeyword; + } + break; + } + case 'e': { + if (name == "else" || name == "enum" || name == "eval" || // to be sure + name == "export" || name == "extends") { + goto mangleKeyword; + } + break; + } + case 'f': { + if (name == "for" || name == "false" || name == "finally" || + name == "function") { + goto mangleKeyword; + } + break; + } + case 'i': { + if (name == "if" || name == "in" || name == "import" || + name == "interface" || name == "implements" || + name == "instanceof") { + goto mangleKeyword; + } + break; + } + case 'l': { + if (name == "let") { + goto mangleKeyword; + } + break; + } + case 'n': { + if (name == "new" || name == "null") { + goto mangleKeyword; + } + break; + } + case 'p': { + if (name == "public" || name == "package" || name == "private" || + name == "protected") { + goto mangleKeyword; + } + break; + } + case 'r': { + if (name == "return") { + goto mangleKeyword; + } + break; + } + case 's': { + if (name == "super" || name == "static" || name == "switch") { + goto mangleKeyword; + } + break; + } + case 't': { + if (name == "try" || name == "this" || name == "true" || + name == "throw" || name == "typeof") { + goto mangleKeyword; + } + break; + } + case 'v': { + if (name == "var" || name == "void") { + goto mangleKeyword; + } + break; + } + case 'w': { + if (name == "with" || name == "while") { + goto mangleKeyword; + } + break; + } + case 'y': { + if (name == "yield") { + goto mangleKeyword; + } + break; + } + mangleKeyword : { name = name + "_"; } + } + } + return name; +} + +} // namespace wasm diff --git a/binaryen/src/asmjs/asmangle.h b/binaryen/src/asmjs/asmangle.h new file mode 100644 --- /dev/null +++ b/binaryen/src/asmjs/asmangle.h @@ -0,0 +1,29 @@ +/* + * Copyright 2018 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef wasm_asmjs_asmangle_h +#define wasm_asmjs_asmangle_h + +#include + +namespace wasm { + +// Mangles a WebAssembly name to a valid JavaScript identifier. +std::string asmangle(std::string name); + +} // namespace wasm + +#endif // wasm_asmjs_asmangle_h diff --git a/binaryen/src/asmjs/shared-constants.cpp b/binaryen/src/asmjs/shared-constants.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/asmjs/shared-constants.cpp @@ -0,0 +1,131 @@ +/* + * Copyright 2016 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "asmjs/shared-constants.h" + +namespace wasm { + +cashew::IString GLOBAL("global"); +cashew::IString NAN_("NaN"); +cashew::IString INFINITY_("Infinity"); +cashew::IString NAN__("nan"); +cashew::IString INFINITY__("infinity"); +cashew::IString TOPMOST("topmost"); +cashew::IString INT8ARRAY("Int8Array"); +cashew::IString INT16ARRAY("Int16Array"); +cashew::IString INT32ARRAY("Int32Array"); +cashew::IString UINT8ARRAY("Uint8Array"); +cashew::IString UINT16ARRAY("Uint16Array"); +cashew::IString UINT32ARRAY("Uint32Array"); +cashew::IString FLOAT32ARRAY("Float32Array"); +cashew::IString FLOAT64ARRAY("Float64Array"); +cashew::IString ARRAY_BUFFER("ArrayBuffer"); +cashew::IString ASM_MODULE("asmModule"); +cashew::IString IMPOSSIBLE_CONTINUE("impossible-continue"); +cashew::IString MATH("Math"); +cashew::IString IMUL("imul"); +cashew::IString CLZ32("clz32"); +cashew::IString FROUND("fround"); +cashew::IString ASM2WASM("asm2wasm"); +cashew::IString MIN("min"); +cashew::IString MAX("max"); +cashew::IString F64_REM("f64-rem"); +cashew::IString F64_TO_INT("f64-to-int"); +cashew::IString F64_TO_UINT("f64-to-uint"); +cashew::IString F64_TO_INT64("f64-to-int64"); +cashew::IString F64_TO_UINT64("f64-to-uint64"); +cashew::IString F32_TO_INT("f32-to-int"); +cashew::IString F32_TO_UINT("f32-to-uint"); +cashew::IString F32_TO_INT64("f32-to-int64"); +cashew::IString F32_TO_UINT64("f32-to-uint64"); +cashew::IString I32S_DIV("i32s-div"); +cashew::IString I32U_DIV("i32u-div"); +cashew::IString I32S_REM("i32s-rem"); +cashew::IString I32U_REM("i32u-rem"); +cashew::IString GLOBAL_MATH("global.Math"); +cashew::IString ABS("abs"); +cashew::IString FLOOR("floor"); +cashew::IString CEIL("ceil"); +cashew::IString SQRT("sqrt"); +cashew::IString POW("pow"); +cashew::IString I32_TEMP("asm2wasm_i32_temp"); +cashew::IString DEBUGGER("debugger"); +cashew::IString BUFFER("buffer"); +cashew::IString ENV("env"); +cashew::IString STACKTOP("STACKTOP"); +cashew::IString STACK_MAX("STACK_MAX"); +cashew::IString INSTRUMENT("instrument"); +cashew::IString MATH_IMUL("Math_imul"); +cashew::IString MATH_ABS("Math_abs"); +cashew::IString MATH_CEIL("Math_ceil"); +cashew::IString MATH_CLZ32("Math_clz32"); +cashew::IString MATH_FLOOR("Math_floor"); +cashew::IString MATH_TRUNC("Math_trunc"); +cashew::IString MATH_SQRT("Math_sqrt"); +cashew::IString MATH_MIN("Math_min"); +cashew::IString MATH_MAX("Math_max"); +cashew::IString WASM_CTZ32("__wasm_ctz_i32"); +cashew::IString WASM_CTZ64("__wasm_ctz_i64"); +cashew::IString WASM_CLZ32("__wasm_clz_i32"); +cashew::IString WASM_CLZ64("__wasm_clz_i64"); +cashew::IString WASM_POPCNT32("__wasm_popcnt_i32"); +cashew::IString WASM_POPCNT64("__wasm_popcnt_i64"); +cashew::IString WASM_ROTL32("__wasm_rotl_i32"); +cashew::IString WASM_ROTL64("__wasm_rotl_i64"); +cashew::IString WASM_ROTR32("__wasm_rotr_i32"); +cashew::IString WASM_ROTR64("__wasm_rotr_i64"); +cashew::IString WASM_MEMORY_GROW("__wasm_memory_grow"); +cashew::IString WASM_MEMORY_SIZE("__wasm_memory_size"); +cashew::IString WASM_FETCH_HIGH_BITS("__wasm_fetch_high_bits"); +cashew::IString INT64_TO_32_HIGH_BITS("i64toi32_i32$HIGH_BITS"); +cashew::IString WASM_NEAREST_F32("__wasm_nearest_f32"); +cashew::IString WASM_NEAREST_F64("__wasm_nearest_f64"); +cashew::IString WASM_TRUNC_F32("__wasm_trunc_f32"); +cashew::IString WASM_TRUNC_F64("__wasm_trunc_f64"); +cashew::IString WASM_I64_MUL("__wasm_i64_mul"); +cashew::IString WASM_I64_SDIV("__wasm_i64_sdiv"); +cashew::IString WASM_I64_UDIV("__wasm_i64_udiv"); +cashew::IString WASM_I64_SREM("__wasm_i64_srem"); +cashew::IString WASM_I64_UREM("__wasm_i64_urem"); + +cashew::IString ASM_FUNC("asmFunc"); +cashew::IString ABORT_FUNC("abort"); +cashew::IString FUNCTION_TABLE("FUNCTION_TABLE"); +cashew::IString NO_RESULT("wasm2js$noresult"); // no result at all +// result in an expression, no temp var +cashew::IString EXPRESSION_RESULT("wasm2js$expresult"); + +namespace ABI { +namespace wasm2js { + +cashew::IString SCRATCH_LOAD_I32("wasm2js_scratch_load_i32"); +cashew::IString SCRATCH_STORE_I32("wasm2js_scratch_store_i32"); +cashew::IString SCRATCH_LOAD_F32("wasm2js_scratch_load_f32"); +cashew::IString SCRATCH_STORE_F32("wasm2js_scratch_store_f32"); +cashew::IString SCRATCH_LOAD_F64("wasm2js_scratch_load_f64"); +cashew::IString SCRATCH_STORE_F64("wasm2js_scratch_store_f64"); +cashew::IString MEMORY_INIT("wasm2js_memory_init"); +cashew::IString MEMORY_FILL("wasm2js_memory_fill"); +cashew::IString MEMORY_COPY("wasm2js_memory_copy"); +cashew::IString DATA_DROP("wasm2js_data_drop"); +cashew::IString ATOMIC_WAIT_I32("wasm2js_atomic_wait_i32"); +cashew::IString ATOMIC_RMW_I64("wasm2js_atomic_rmw_i64"); +cashew::IString GET_STASHED_BITS("wasm2js_get_stashed_bits"); + +} // namespace wasm2js +} // namespace ABI + +} // namespace wasm diff --git a/binaryen/src/asmjs/shared-constants.h b/binaryen/src/asmjs/shared-constants.h new file mode 100644 --- /dev/null +++ b/binaryen/src/asmjs/shared-constants.h @@ -0,0 +1,114 @@ +/* + * Copyright 2015 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef wasm_asmjs_shared_constants_h +#define wasm_asmjs_shared_constants_h + +#include "emscripten-optimizer/istring.h" + +namespace wasm { + +extern cashew::IString GLOBAL; +extern cashew::IString NAN_; +extern cashew::IString INFINITY_; +extern cashew::IString NAN__; +extern cashew::IString INFINITY__; +extern cashew::IString TOPMOST; +extern cashew::IString INT8ARRAY; +extern cashew::IString INT16ARRAY; +extern cashew::IString INT32ARRAY; +extern cashew::IString UINT8ARRAY; +extern cashew::IString UINT16ARRAY; +extern cashew::IString UINT32ARRAY; +extern cashew::IString FLOAT32ARRAY; +extern cashew::IString FLOAT64ARRAY; +extern cashew::IString ARRAY_BUFFER; +extern cashew::IString ASM_MODULE; +extern cashew::IString IMPOSSIBLE_CONTINUE; +extern cashew::IString MATH; +extern cashew::IString IMUL; +extern cashew::IString CLZ32; +extern cashew::IString FROUND; +extern cashew::IString ASM2WASM; +extern cashew::IString MIN; +extern cashew::IString MAX; +extern cashew::IString F64_REM; +extern cashew::IString F64_TO_INT; +extern cashew::IString F64_TO_UINT; +extern cashew::IString F64_TO_INT64; +extern cashew::IString F64_TO_UINT64; +extern cashew::IString F32_TO_INT; +extern cashew::IString F32_TO_UINT; +extern cashew::IString F32_TO_INT64; +extern cashew::IString F32_TO_UINT64; +extern cashew::IString I32S_DIV; +extern cashew::IString I32U_DIV; +extern cashew::IString I32S_REM; +extern cashew::IString I32U_REM; +extern cashew::IString GLOBAL_MATH; +extern cashew::IString ABS; +extern cashew::IString FLOOR; +extern cashew::IString CEIL; +extern cashew::IString SQRT; +extern cashew::IString POW; +extern cashew::IString I32_TEMP; +extern cashew::IString DEBUGGER; +extern cashew::IString BUFFER; +extern cashew::IString ENV; +extern cashew::IString STACKTOP; +extern cashew::IString STACK_MAX; +extern cashew::IString INSTRUMENT; +extern cashew::IString MATH_IMUL; +extern cashew::IString MATH_ABS; +extern cashew::IString MATH_CEIL; +extern cashew::IString MATH_CLZ32; +extern cashew::IString MATH_FLOOR; +extern cashew::IString MATH_TRUNC; +extern cashew::IString MATH_SQRT; +extern cashew::IString MATH_MIN; +extern cashew::IString MATH_MAX; +extern cashew::IString WASM_CTZ32; +extern cashew::IString WASM_CTZ64; +extern cashew::IString WASM_CLZ32; +extern cashew::IString WASM_CLZ64; +extern cashew::IString WASM_POPCNT32; +extern cashew::IString WASM_POPCNT64; +extern cashew::IString WASM_ROTL32; +extern cashew::IString WASM_ROTL64; +extern cashew::IString WASM_ROTR32; +extern cashew::IString WASM_ROTR64; +extern cashew::IString WASM_MEMORY_GROW; +extern cashew::IString WASM_MEMORY_SIZE; +extern cashew::IString WASM_FETCH_HIGH_BITS; +extern cashew::IString INT64_TO_32_HIGH_BITS; +extern cashew::IString WASM_NEAREST_F32; +extern cashew::IString WASM_NEAREST_F64; +extern cashew::IString WASM_TRUNC_F32; +extern cashew::IString WASM_TRUNC_F64; +extern cashew::IString WASM_I64_MUL; +extern cashew::IString WASM_I64_SDIV; +extern cashew::IString WASM_I64_UDIV; +extern cashew::IString WASM_I64_SREM; +extern cashew::IString WASM_I64_UREM; +// wasm2js constants +extern cashew::IString ASM_FUNC; +extern cashew::IString ABORT_FUNC; +extern cashew::IString FUNCTION_TABLE; +extern cashew::IString NO_RESULT; +extern cashew::IString EXPRESSION_RESULT; +} // namespace wasm + +#endif // wasm_asmjs_shared_constants_h diff --git a/binaryen/src/binaryen-c.cpp b/binaryen/src/binaryen-c.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/binaryen-c.cpp @@ -0,0 +1,4259 @@ +/* + * Copyright 2016 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +//=============================== +// Binaryen C API implementation +//=============================== + +#include + +#include "binaryen-c.h" +#include "cfg/Relooper.h" +#include "ir/utils.h" +#include "pass.h" +#include "shell-interface.h" +#include "support/colors.h" +#include "wasm-binary.h" +#include "wasm-builder.h" +#include "wasm-interpreter.h" +#include "wasm-printing.h" +#include "wasm-s-parser.h" +#include "wasm-validator.h" +#include "wasm.h" +#include "wasm2js.h" +#include +#include + +#ifdef __EMSCRIPTEN__ +#include +#endif + +using namespace wasm; + +// Literal utilities + +static_assert(sizeof(BinaryenLiteral) == sizeof(Literal), + "Binaryen C API literal must match wasm.h"); + +BinaryenLiteral toBinaryenLiteral(Literal x) { + BinaryenLiteral ret; + ret.type = x.type.getID(); + TODO_SINGLE_COMPOUND(x.type); + switch (x.type.getBasic()) { + case Type::i32: + ret.i32 = x.geti32(); + break; + case Type::i64: + ret.i64 = x.geti64(); + break; + case Type::f32: + ret.i32 = x.reinterpreti32(); + break; + case Type::f64: + ret.i64 = x.reinterpreti64(); + break; + case Type::v128: + memcpy(&ret.v128, x.getv128Ptr(), 16); + break; + case Type::funcref: + ret.func = x.isNull() ? nullptr : x.getFunc().c_str(); + break; + case Type::externref: + case Type::exnref: + case Type::anyref: + case Type::eqref: + assert(x.isNull() && "unexpected non-null reference type literal"); + break; + case Type::i31ref: + WASM_UNREACHABLE("TODO: i31ref"); + case Type::none: + case Type::unreachable: + WASM_UNREACHABLE("unexpected type"); + } + return ret; +} + +Literal fromBinaryenLiteral(BinaryenLiteral x) { + switch (x.type) { + case Type::i32: + return Literal(x.i32); + case Type::i64: + return Literal(x.i64); + case Type::f32: + return Literal(x.i32).castToF32(); + case Type::f64: + return Literal(x.i64).castToF64(); + case Type::v128: + return Literal(x.v128); + case Type::funcref: + return Literal::makeFunc(x.func); + case Type::externref: + case Type::exnref: + case Type::anyref: + case Type::eqref: + return Literal::makeNull(Type(x.type)); + case Type::i31ref: + WASM_UNREACHABLE("TODO: i31ref"); + case Type::none: + case Type::unreachable: + WASM_UNREACHABLE("unexpected type"); + } + WASM_UNREACHABLE("invalid type"); +} + +// Mutexes (global for now; in theory if multiple modules +// are used at once this should be optimized to be per- +// module, but likely it doesn't matter) + +static std::mutex BinaryenFunctionMutex; + +// Optimization options +static PassOptions globalPassOptions = + PassOptions::getWithDefaultOptimizationOptions(); + +extern "C" { + +// +// ========== Module Creation ========== +// + +// Core types + +BinaryenType BinaryenTypeNone(void) { return Type::none; } +BinaryenType BinaryenTypeInt32(void) { return Type::i32; } +BinaryenType BinaryenTypeInt64(void) { return Type::i64; } +BinaryenType BinaryenTypeFloat32(void) { return Type::f32; } +BinaryenType BinaryenTypeFloat64(void) { return Type::f64; } +BinaryenType BinaryenTypeVec128(void) { return Type::v128; } +BinaryenType BinaryenTypeFuncref(void) { return Type::funcref; } +BinaryenType BinaryenTypeExternref(void) { return Type::externref; } +BinaryenType BinaryenTypeExnref(void) { return Type::exnref; } +BinaryenType BinaryenTypeAnyref(void) { return Type::anyref; } +BinaryenType BinaryenTypeEqref(void) { return Type::eqref; } +BinaryenType BinaryenTypeI31ref(void) { return Type::i31ref; } +BinaryenType BinaryenTypeUnreachable(void) { return Type::unreachable; } +BinaryenType BinaryenTypeAuto(void) { return uintptr_t(-1); } + +BinaryenType BinaryenTypeCreate(BinaryenType* types, uint32_t numTypes) { + std::vector typeVec; + typeVec.reserve(numTypes); + for (size_t i = 0; i < numTypes; ++i) { + typeVec.push_back(Type(types[i])); + } + return Type(typeVec).getID(); +} + +uint32_t BinaryenTypeArity(BinaryenType t) { return Type(t).size(); } + +void BinaryenTypeExpand(BinaryenType t, BinaryenType* buf) { + Type types(t); + size_t i = 0; + for (const auto& type : types) { + buf[i++] = type.getID(); + } +} + +WASM_DEPRECATED BinaryenType BinaryenNone(void) { return Type::none; } +WASM_DEPRECATED BinaryenType BinaryenInt32(void) { return Type::i32; } +WASM_DEPRECATED BinaryenType BinaryenInt64(void) { return Type::i64; } +WASM_DEPRECATED BinaryenType BinaryenFloat32(void) { return Type::f32; } +WASM_DEPRECATED BinaryenType BinaryenFloat64(void) { return Type::f64; } +WASM_DEPRECATED BinaryenType BinaryenUndefined(void) { return uint32_t(-1); } + +// Expression ids + +BinaryenExpressionId BinaryenInvalidId(void) { + return Expression::Id::InvalidId; +} +BinaryenExpressionId BinaryenBlockId(void) { return Expression::Id::BlockId; } +BinaryenExpressionId BinaryenIfId(void) { return Expression::Id::IfId; } +BinaryenExpressionId BinaryenLoopId(void) { return Expression::Id::LoopId; } +BinaryenExpressionId BinaryenBreakId(void) { return Expression::Id::BreakId; } +BinaryenExpressionId BinaryenSwitchId(void) { return Expression::Id::SwitchId; } +BinaryenExpressionId BinaryenCallId(void) { return Expression::Id::CallId; } +BinaryenExpressionId BinaryenCallIndirectId(void) { + return Expression::Id::CallIndirectId; +} +BinaryenExpressionId BinaryenLocalGetId(void) { + return Expression::Id::LocalGetId; +} +BinaryenExpressionId BinaryenLocalSetId(void) { + return Expression::Id::LocalSetId; +} +BinaryenExpressionId BinaryenGlobalGetId(void) { + return Expression::Id::GlobalGetId; +} +BinaryenExpressionId BinaryenGlobalSetId(void) { + return Expression::Id::GlobalSetId; +} +BinaryenExpressionId BinaryenLoadId(void) { return Expression::Id::LoadId; } +BinaryenExpressionId BinaryenStoreId(void) { return Expression::Id::StoreId; } +BinaryenExpressionId BinaryenConstId(void) { return Expression::Id::ConstId; } +BinaryenExpressionId BinaryenUnaryId(void) { return Expression::Id::UnaryId; } +BinaryenExpressionId BinaryenBinaryId(void) { return Expression::Id::BinaryId; } +BinaryenExpressionId BinaryenSelectId(void) { return Expression::Id::SelectId; } +BinaryenExpressionId BinaryenDropId(void) { return Expression::Id::DropId; } +BinaryenExpressionId BinaryenReturnId(void) { return Expression::Id::ReturnId; } +BinaryenExpressionId BinaryenMemorySizeId(void) { + return Expression::Id::MemorySizeId; +} +BinaryenExpressionId BinaryenMemoryGrowId(void) { + return Expression::Id::MemoryGrowId; +} +BinaryenExpressionId BinaryenNopId(void) { return Expression::Id::NopId; } +BinaryenExpressionId BinaryenUnreachableId(void) { + return Expression::Id::UnreachableId; +} +BinaryenExpressionId BinaryenAtomicCmpxchgId(void) { + return Expression::Id::AtomicCmpxchgId; +} +BinaryenExpressionId BinaryenAtomicRMWId(void) { + return Expression::Id::AtomicRMWId; +} +BinaryenExpressionId BinaryenAtomicWaitId(void) { + return Expression::Id::AtomicWaitId; +} +BinaryenExpressionId BinaryenAtomicNotifyId(void) { + return Expression::Id::AtomicNotifyId; +} +BinaryenExpressionId BinaryenAtomicFenceId(void) { + return Expression::Id::AtomicFenceId; +} +BinaryenExpressionId BinaryenSIMDExtractId(void) { + return Expression::Id::SIMDExtractId; +} +BinaryenExpressionId BinaryenSIMDReplaceId(void) { + return Expression::Id::SIMDReplaceId; +} +BinaryenExpressionId BinaryenSIMDShuffleId(void) { + return Expression::Id::SIMDShuffleId; +} +BinaryenExpressionId BinaryenSIMDTernaryId(void) { + return Expression::Id::SIMDTernaryId; +} +BinaryenExpressionId BinaryenSIMDShiftId(void) { + return Expression::Id::SIMDShiftId; +} +BinaryenExpressionId BinaryenSIMDLoadId(void) { + return Expression::Id::SIMDLoadId; +} +BinaryenExpressionId BinaryenMemoryInitId(void) { + return Expression::Id::MemoryInitId; +} +BinaryenExpressionId BinaryenDataDropId(void) { + return Expression::Id::DataDropId; +} +BinaryenExpressionId BinaryenMemoryCopyId(void) { + return Expression::Id::MemoryCopyId; +} +BinaryenExpressionId BinaryenMemoryFillId(void) { + return Expression::Id::MemoryFillId; +} +BinaryenExpressionId BinaryenRefNullId(void) { + return Expression::Id::RefNullId; +} +BinaryenExpressionId BinaryenRefIsNullId(void) { + return Expression::Id::RefIsNullId; +} +BinaryenExpressionId BinaryenRefFuncId(void) { + return Expression::Id::RefFuncId; +} +BinaryenExpressionId BinaryenRefEqId(void) { return Expression::Id::RefEqId; } +BinaryenExpressionId BinaryenTryId(void) { return Expression::Id::TryId; } +BinaryenExpressionId BinaryenThrowId(void) { return Expression::Id::ThrowId; } +BinaryenExpressionId BinaryenRethrowId(void) { + return Expression::Id::RethrowId; +} +BinaryenExpressionId BinaryenBrOnExnId(void) { + return Expression::Id::BrOnExnId; +} +BinaryenExpressionId BinaryenTupleMakeId(void) { + return Expression::Id::TupleMakeId; +} +BinaryenExpressionId BinaryenTupleExtractId(void) { + return Expression::Id::TupleExtractId; +} +BinaryenExpressionId BinaryenPopId(void) { return Expression::Id::PopId; } +BinaryenExpressionId BinaryenI31NewId(void) { return Expression::Id::I31NewId; } +BinaryenExpressionId BinaryenI31GetId(void) { return Expression::Id::I31GetId; } +BinaryenExpressionId BinaryenRefTestId(void) { + return Expression::Id::RefTestId; +} +BinaryenExpressionId BinaryenRefCastId(void) { + return Expression::Id::RefCastId; +} +BinaryenExpressionId BinaryenBrOnCastId(void) { + return Expression::Id::BrOnCastId; +} +BinaryenExpressionId BinaryenRttCanonId(void) { + return Expression::Id::RttCanonId; +} +BinaryenExpressionId BinaryenRttSubId(void) { return Expression::Id::RttSubId; } +BinaryenExpressionId BinaryenStructNewId(void) { + return Expression::Id::StructNewId; +} +BinaryenExpressionId BinaryenStructGetId(void) { + return Expression::Id::StructGetId; +} +BinaryenExpressionId BinaryenStructSetId(void) { + return Expression::Id::StructSetId; +} +BinaryenExpressionId BinaryenArrayNewId(void) { + return Expression::Id::ArrayNewId; +} +BinaryenExpressionId BinaryenArrayGetId(void) { + return Expression::Id::ArrayGetId; +} +BinaryenExpressionId BinaryenArraySetId(void) { + return Expression::Id::ArraySetId; +} +BinaryenExpressionId BinaryenArrayLenId(void) { + return Expression::Id::ArrayLenId; +} + +// External kinds + +BinaryenExternalKind BinaryenExternalFunction(void) { + return static_cast(ExternalKind::Function); +} +BinaryenExternalKind BinaryenExternalTable(void) { + return static_cast(ExternalKind::Table); +} +BinaryenExternalKind BinaryenExternalMemory(void) { + return static_cast(ExternalKind::Memory); +} +BinaryenExternalKind BinaryenExternalGlobal(void) { + return static_cast(ExternalKind::Global); +} +BinaryenExternalKind BinaryenExternalEvent(void) { + return static_cast(ExternalKind::Event); +} + +// Features + +BinaryenFeatures BinaryenFeatureMVP(void) { + return static_cast(FeatureSet::MVP); +} +BinaryenFeatures BinaryenFeatureAtomics(void) { + return static_cast(FeatureSet::Atomics); +} +BinaryenFeatures BinaryenFeatureBulkMemory(void) { + return static_cast(FeatureSet::BulkMemory); +} +BinaryenFeatures BinaryenFeatureMutableGlobals(void) { + return static_cast(FeatureSet::MutableGlobals); +} +BinaryenFeatures BinaryenFeatureNontrappingFPToInt(void) { + return static_cast(FeatureSet::TruncSat); +} +BinaryenFeatures BinaryenFeatureSignExt(void) { + return static_cast(FeatureSet::SignExt); +} +BinaryenFeatures BinaryenFeatureSIMD128(void) { + return static_cast(FeatureSet::SIMD); +} +BinaryenFeatures BinaryenFeatureExceptionHandling(void) { + return static_cast(FeatureSet::ExceptionHandling); +} +BinaryenFeatures BinaryenFeatureTailCall(void) { + return static_cast(FeatureSet::TailCall); +} +BinaryenFeatures BinaryenFeatureReferenceTypes(void) { + return static_cast(FeatureSet::ReferenceTypes); +} +BinaryenFeatures BinaryenFeatureMultivalue(void) { + return static_cast(FeatureSet::Multivalue); +} +BinaryenFeatures BinaryenFeatureGC(void) { + return static_cast(FeatureSet::GC); +} +BinaryenFeatures BinaryenFeatureMemory64(void) { + return static_cast(FeatureSet::Memory64); +} +BinaryenFeatures BinaryenFeatureAll(void) { + return static_cast(FeatureSet::All); +} + +// Modules + +BinaryenModuleRef BinaryenModuleCreate(void) { return new Module(); } +void BinaryenModuleDispose(BinaryenModuleRef module) { delete (Module*)module; } + +// Literals + +BinaryenLiteral BinaryenLiteralInt32(int32_t x) { + return toBinaryenLiteral(Literal(x)); +} +BinaryenLiteral BinaryenLiteralInt64(int64_t x) { + return toBinaryenLiteral(Literal(x)); +} +BinaryenLiteral BinaryenLiteralFloat32(float x) { + return toBinaryenLiteral(Literal(x)); +} +BinaryenLiteral BinaryenLiteralFloat64(double x) { + return toBinaryenLiteral(Literal(x)); +} +BinaryenLiteral BinaryenLiteralVec128(const uint8_t x[16]) { + return toBinaryenLiteral(Literal(x)); +} +BinaryenLiteral BinaryenLiteralFloat32Bits(int32_t x) { + return toBinaryenLiteral(Literal(x).castToF32()); +} +BinaryenLiteral BinaryenLiteralFloat64Bits(int64_t x) { + return toBinaryenLiteral(Literal(x).castToF64()); +} + +// Expressions + +BinaryenOp BinaryenClzInt32(void) { return ClzInt32; } +BinaryenOp BinaryenCtzInt32(void) { return CtzInt32; } +BinaryenOp BinaryenPopcntInt32(void) { return PopcntInt32; } +BinaryenOp BinaryenNegFloat32(void) { return NegFloat32; } +BinaryenOp BinaryenAbsFloat32(void) { return AbsFloat32; } +BinaryenOp BinaryenCeilFloat32(void) { return CeilFloat32; } +BinaryenOp BinaryenFloorFloat32(void) { return FloorFloat32; } +BinaryenOp BinaryenTruncFloat32(void) { return TruncFloat32; } +BinaryenOp BinaryenNearestFloat32(void) { return NearestFloat32; } +BinaryenOp BinaryenSqrtFloat32(void) { return SqrtFloat32; } +BinaryenOp BinaryenEqZInt32(void) { return EqZInt32; } +BinaryenOp BinaryenClzInt64(void) { return ClzInt64; } +BinaryenOp BinaryenCtzInt64(void) { return CtzInt64; } +BinaryenOp BinaryenPopcntInt64(void) { return PopcntInt64; } +BinaryenOp BinaryenNegFloat64(void) { return NegFloat64; } +BinaryenOp BinaryenAbsFloat64(void) { return AbsFloat64; } +BinaryenOp BinaryenCeilFloat64(void) { return CeilFloat64; } +BinaryenOp BinaryenFloorFloat64(void) { return FloorFloat64; } +BinaryenOp BinaryenTruncFloat64(void) { return TruncFloat64; } +BinaryenOp BinaryenNearestFloat64(void) { return NearestFloat64; } +BinaryenOp BinaryenSqrtFloat64(void) { return SqrtFloat64; } +BinaryenOp BinaryenEqZInt64(void) { return EqZInt64; } +BinaryenOp BinaryenExtendSInt32(void) { return ExtendSInt32; } +BinaryenOp BinaryenExtendUInt32(void) { return ExtendUInt32; } +BinaryenOp BinaryenWrapInt64(void) { return WrapInt64; } +BinaryenOp BinaryenTruncSFloat32ToInt32(void) { return TruncSFloat32ToInt32; } +BinaryenOp BinaryenTruncSFloat32ToInt64(void) { return TruncSFloat32ToInt64; } +BinaryenOp BinaryenTruncUFloat32ToInt32(void) { return TruncUFloat32ToInt32; } +BinaryenOp BinaryenTruncUFloat32ToInt64(void) { return TruncUFloat32ToInt64; } +BinaryenOp BinaryenTruncSFloat64ToInt32(void) { return TruncSFloat64ToInt32; } +BinaryenOp BinaryenTruncSFloat64ToInt64(void) { return TruncSFloat64ToInt64; } +BinaryenOp BinaryenTruncUFloat64ToInt32(void) { return TruncUFloat64ToInt32; } +BinaryenOp BinaryenTruncUFloat64ToInt64(void) { return TruncUFloat64ToInt64; } +BinaryenOp BinaryenReinterpretFloat32(void) { return ReinterpretFloat32; } +BinaryenOp BinaryenReinterpretFloat64(void) { return ReinterpretFloat64; } +BinaryenOp BinaryenExtendS8Int32(void) { return ExtendS8Int32; } +BinaryenOp BinaryenExtendS16Int32(void) { return ExtendS16Int32; } +BinaryenOp BinaryenExtendS8Int64(void) { return ExtendS8Int64; } +BinaryenOp BinaryenExtendS16Int64(void) { return ExtendS16Int64; } +BinaryenOp BinaryenExtendS32Int64(void) { return ExtendS32Int64; } +BinaryenOp BinaryenConvertSInt32ToFloat32(void) { + return ConvertSInt32ToFloat32; +} +BinaryenOp BinaryenConvertSInt32ToFloat64(void) { + return ConvertSInt32ToFloat64; +} +BinaryenOp BinaryenConvertUInt32ToFloat32(void) { + return ConvertUInt32ToFloat32; +} +BinaryenOp BinaryenConvertUInt32ToFloat64(void) { + return ConvertUInt32ToFloat64; +} +BinaryenOp BinaryenConvertSInt64ToFloat32(void) { + return ConvertSInt64ToFloat32; +} +BinaryenOp BinaryenConvertSInt64ToFloat64(void) { + return ConvertSInt64ToFloat64; +} +BinaryenOp BinaryenConvertUInt64ToFloat32(void) { + return ConvertUInt64ToFloat32; +} +BinaryenOp BinaryenConvertUInt64ToFloat64(void) { + return ConvertUInt64ToFloat64; +} +BinaryenOp BinaryenPromoteFloat32(void) { return PromoteFloat32; } +BinaryenOp BinaryenDemoteFloat64(void) { return DemoteFloat64; } +BinaryenOp BinaryenReinterpretInt32(void) { return ReinterpretInt32; } +BinaryenOp BinaryenReinterpretInt64(void) { return ReinterpretInt64; } +BinaryenOp BinaryenAddInt32(void) { return AddInt32; } +BinaryenOp BinaryenSubInt32(void) { return SubInt32; } +BinaryenOp BinaryenMulInt32(void) { return MulInt32; } +BinaryenOp BinaryenDivSInt32(void) { return DivSInt32; } +BinaryenOp BinaryenDivUInt32(void) { return DivUInt32; } +BinaryenOp BinaryenRemSInt32(void) { return RemSInt32; } +BinaryenOp BinaryenRemUInt32(void) { return RemUInt32; } +BinaryenOp BinaryenAndInt32(void) { return AndInt32; } +BinaryenOp BinaryenOrInt32(void) { return OrInt32; } +BinaryenOp BinaryenXorInt32(void) { return XorInt32; } +BinaryenOp BinaryenShlInt32(void) { return ShlInt32; } +BinaryenOp BinaryenShrUInt32(void) { return ShrUInt32; } +BinaryenOp BinaryenShrSInt32(void) { return ShrSInt32; } +BinaryenOp BinaryenRotLInt32(void) { return RotLInt32; } +BinaryenOp BinaryenRotRInt32(void) { return RotRInt32; } +BinaryenOp BinaryenEqInt32(void) { return EqInt32; } +BinaryenOp BinaryenNeInt32(void) { return NeInt32; } +BinaryenOp BinaryenLtSInt32(void) { return LtSInt32; } +BinaryenOp BinaryenLtUInt32(void) { return LtUInt32; } +BinaryenOp BinaryenLeSInt32(void) { return LeSInt32; } +BinaryenOp BinaryenLeUInt32(void) { return LeUInt32; } +BinaryenOp BinaryenGtSInt32(void) { return GtSInt32; } +BinaryenOp BinaryenGtUInt32(void) { return GtUInt32; } +BinaryenOp BinaryenGeSInt32(void) { return GeSInt32; } +BinaryenOp BinaryenGeUInt32(void) { return GeUInt32; } +BinaryenOp BinaryenAddInt64(void) { return AddInt64; } +BinaryenOp BinaryenSubInt64(void) { return SubInt64; } +BinaryenOp BinaryenMulInt64(void) { return MulInt64; } +BinaryenOp BinaryenDivSInt64(void) { return DivSInt64; } +BinaryenOp BinaryenDivUInt64(void) { return DivUInt64; } +BinaryenOp BinaryenRemSInt64(void) { return RemSInt64; } +BinaryenOp BinaryenRemUInt64(void) { return RemUInt64; } +BinaryenOp BinaryenAndInt64(void) { return AndInt64; } +BinaryenOp BinaryenOrInt64(void) { return OrInt64; } +BinaryenOp BinaryenXorInt64(void) { return XorInt64; } +BinaryenOp BinaryenShlInt64(void) { return ShlInt64; } +BinaryenOp BinaryenShrUInt64(void) { return ShrUInt64; } +BinaryenOp BinaryenShrSInt64(void) { return ShrSInt64; } +BinaryenOp BinaryenRotLInt64(void) { return RotLInt64; } +BinaryenOp BinaryenRotRInt64(void) { return RotRInt64; } +BinaryenOp BinaryenEqInt64(void) { return EqInt64; } +BinaryenOp BinaryenNeInt64(void) { return NeInt64; } +BinaryenOp BinaryenLtSInt64(void) { return LtSInt64; } +BinaryenOp BinaryenLtUInt64(void) { return LtUInt64; } +BinaryenOp BinaryenLeSInt64(void) { return LeSInt64; } +BinaryenOp BinaryenLeUInt64(void) { return LeUInt64; } +BinaryenOp BinaryenGtSInt64(void) { return GtSInt64; } +BinaryenOp BinaryenGtUInt64(void) { return GtUInt64; } +BinaryenOp BinaryenGeSInt64(void) { return GeSInt64; } +BinaryenOp BinaryenGeUInt64(void) { return GeUInt64; } +BinaryenOp BinaryenAddFloat32(void) { return AddFloat32; } +BinaryenOp BinaryenSubFloat32(void) { return SubFloat32; } +BinaryenOp BinaryenMulFloat32(void) { return MulFloat32; } +BinaryenOp BinaryenDivFloat32(void) { return DivFloat32; } +BinaryenOp BinaryenCopySignFloat32(void) { return CopySignFloat32; } +BinaryenOp BinaryenMinFloat32(void) { return MinFloat32; } +BinaryenOp BinaryenMaxFloat32(void) { return MaxFloat32; } +BinaryenOp BinaryenEqFloat32(void) { return EqFloat32; } +BinaryenOp BinaryenNeFloat32(void) { return NeFloat32; } +BinaryenOp BinaryenLtFloat32(void) { return LtFloat32; } +BinaryenOp BinaryenLeFloat32(void) { return LeFloat32; } +BinaryenOp BinaryenGtFloat32(void) { return GtFloat32; } +BinaryenOp BinaryenGeFloat32(void) { return GeFloat32; } +BinaryenOp BinaryenAddFloat64(void) { return AddFloat64; } +BinaryenOp BinaryenSubFloat64(void) { return SubFloat64; } +BinaryenOp BinaryenMulFloat64(void) { return MulFloat64; } +BinaryenOp BinaryenDivFloat64(void) { return DivFloat64; } +BinaryenOp BinaryenCopySignFloat64(void) { return CopySignFloat64; } +BinaryenOp BinaryenMinFloat64(void) { return MinFloat64; } +BinaryenOp BinaryenMaxFloat64(void) { return MaxFloat64; } +BinaryenOp BinaryenEqFloat64(void) { return EqFloat64; } +BinaryenOp BinaryenNeFloat64(void) { return NeFloat64; } +BinaryenOp BinaryenLtFloat64(void) { return LtFloat64; } +BinaryenOp BinaryenLeFloat64(void) { return LeFloat64; } +BinaryenOp BinaryenGtFloat64(void) { return GtFloat64; } +BinaryenOp BinaryenGeFloat64(void) { return GeFloat64; } +BinaryenOp BinaryenAtomicRMWAdd(void) { return AtomicRMWOp::Add; } +BinaryenOp BinaryenAtomicRMWSub(void) { return AtomicRMWOp::Sub; } +BinaryenOp BinaryenAtomicRMWAnd(void) { return AtomicRMWOp::And; } +BinaryenOp BinaryenAtomicRMWOr(void) { return AtomicRMWOp::Or; } +BinaryenOp BinaryenAtomicRMWXor(void) { return AtomicRMWOp::Xor; } +BinaryenOp BinaryenAtomicRMWXchg(void) { return AtomicRMWOp::Xchg; } +BinaryenOp BinaryenTruncSatSFloat32ToInt32(void) { + return TruncSatSFloat32ToInt32; +} +BinaryenOp BinaryenTruncSatSFloat32ToInt64(void) { + return TruncSatSFloat32ToInt64; +} +BinaryenOp BinaryenTruncSatUFloat32ToInt32(void) { + return TruncSatUFloat32ToInt32; +} +BinaryenOp BinaryenTruncSatUFloat32ToInt64(void) { + return TruncSatUFloat32ToInt64; +} +BinaryenOp BinaryenTruncSatSFloat64ToInt32(void) { + return TruncSatSFloat64ToInt32; +} +BinaryenOp BinaryenTruncSatSFloat64ToInt64(void) { + return TruncSatSFloat64ToInt64; +} +BinaryenOp BinaryenTruncSatUFloat64ToInt32(void) { + return TruncSatUFloat64ToInt32; +} +BinaryenOp BinaryenTruncSatUFloat64ToInt64(void) { + return TruncSatUFloat64ToInt64; +} +BinaryenOp BinaryenSplatVecI8x16(void) { return SplatVecI8x16; } +BinaryenOp BinaryenExtractLaneSVecI8x16(void) { return ExtractLaneSVecI8x16; } +BinaryenOp BinaryenExtractLaneUVecI8x16(void) { return ExtractLaneUVecI8x16; } +BinaryenOp BinaryenReplaceLaneVecI8x16(void) { return ReplaceLaneVecI8x16; } +BinaryenOp BinaryenSplatVecI16x8(void) { return SplatVecI16x8; } +BinaryenOp BinaryenExtractLaneSVecI16x8(void) { return ExtractLaneSVecI16x8; } +BinaryenOp BinaryenExtractLaneUVecI16x8(void) { return ExtractLaneUVecI16x8; } +BinaryenOp BinaryenReplaceLaneVecI16x8(void) { return ReplaceLaneVecI16x8; } +BinaryenOp BinaryenSplatVecI32x4(void) { return SplatVecI32x4; } +BinaryenOp BinaryenExtractLaneVecI32x4(void) { return ExtractLaneVecI32x4; } +BinaryenOp BinaryenReplaceLaneVecI32x4(void) { return ReplaceLaneVecI32x4; } +BinaryenOp BinaryenSplatVecI64x2(void) { return SplatVecI64x2; } +BinaryenOp BinaryenExtractLaneVecI64x2(void) { return ExtractLaneVecI64x2; } +BinaryenOp BinaryenReplaceLaneVecI64x2(void) { return ReplaceLaneVecI64x2; } +BinaryenOp BinaryenSplatVecF32x4(void) { return SplatVecF32x4; } +BinaryenOp BinaryenExtractLaneVecF32x4(void) { return ExtractLaneVecF32x4; } +BinaryenOp BinaryenReplaceLaneVecF32x4(void) { return ReplaceLaneVecF32x4; } +BinaryenOp BinaryenSplatVecF64x2(void) { return SplatVecF64x2; } +BinaryenOp BinaryenExtractLaneVecF64x2(void) { return ExtractLaneVecF64x2; } +BinaryenOp BinaryenReplaceLaneVecF64x2(void) { return ReplaceLaneVecF64x2; } +BinaryenOp BinaryenEqVecI8x16(void) { return EqVecI8x16; } +BinaryenOp BinaryenNeVecI8x16(void) { return NeVecI8x16; } +BinaryenOp BinaryenLtSVecI8x16(void) { return LtSVecI8x16; } +BinaryenOp BinaryenLtUVecI8x16(void) { return LtUVecI8x16; } +BinaryenOp BinaryenGtSVecI8x16(void) { return GtSVecI8x16; } +BinaryenOp BinaryenGtUVecI8x16(void) { return GtUVecI8x16; } +BinaryenOp BinaryenLeSVecI8x16(void) { return LeSVecI8x16; } +BinaryenOp BinaryenLeUVecI8x16(void) { return LeUVecI8x16; } +BinaryenOp BinaryenGeSVecI8x16(void) { return GeSVecI8x16; } +BinaryenOp BinaryenGeUVecI8x16(void) { return GeUVecI8x16; } +BinaryenOp BinaryenEqVecI16x8(void) { return EqVecI16x8; } +BinaryenOp BinaryenNeVecI16x8(void) { return NeVecI16x8; } +BinaryenOp BinaryenLtSVecI16x8(void) { return LtSVecI16x8; } +BinaryenOp BinaryenLtUVecI16x8(void) { return LtUVecI16x8; } +BinaryenOp BinaryenGtSVecI16x8(void) { return GtSVecI16x8; } +BinaryenOp BinaryenGtUVecI16x8(void) { return GtUVecI16x8; } +BinaryenOp BinaryenLeSVecI16x8(void) { return LeSVecI16x8; } +BinaryenOp BinaryenLeUVecI16x8(void) { return LeUVecI16x8; } +BinaryenOp BinaryenGeSVecI16x8(void) { return GeSVecI16x8; } +BinaryenOp BinaryenGeUVecI16x8(void) { return GeUVecI16x8; } +BinaryenOp BinaryenEqVecI32x4(void) { return EqVecI32x4; } +BinaryenOp BinaryenNeVecI32x4(void) { return NeVecI32x4; } +BinaryenOp BinaryenLtSVecI32x4(void) { return LtSVecI32x4; } +BinaryenOp BinaryenLtUVecI32x4(void) { return LtUVecI32x4; } +BinaryenOp BinaryenGtSVecI32x4(void) { return GtSVecI32x4; } +BinaryenOp BinaryenGtUVecI32x4(void) { return GtUVecI32x4; } +BinaryenOp BinaryenLeSVecI32x4(void) { return LeSVecI32x4; } +BinaryenOp BinaryenLeUVecI32x4(void) { return LeUVecI32x4; } +BinaryenOp BinaryenGeSVecI32x4(void) { return GeSVecI32x4; } +BinaryenOp BinaryenGeUVecI32x4(void) { return GeUVecI32x4; } +BinaryenOp BinaryenEqVecF32x4(void) { return EqVecF32x4; } +BinaryenOp BinaryenNeVecF32x4(void) { return NeVecF32x4; } +BinaryenOp BinaryenLtVecF32x4(void) { return LtVecF32x4; } +BinaryenOp BinaryenGtVecF32x4(void) { return GtVecF32x4; } +BinaryenOp BinaryenLeVecF32x4(void) { return LeVecF32x4; } +BinaryenOp BinaryenGeVecF32x4(void) { return GeVecF32x4; } +BinaryenOp BinaryenEqVecF64x2(void) { return EqVecF64x2; } +BinaryenOp BinaryenNeVecF64x2(void) { return NeVecF64x2; } +BinaryenOp BinaryenLtVecF64x2(void) { return LtVecF64x2; } +BinaryenOp BinaryenGtVecF64x2(void) { return GtVecF64x2; } +BinaryenOp BinaryenLeVecF64x2(void) { return LeVecF64x2; } +BinaryenOp BinaryenGeVecF64x2(void) { return GeVecF64x2; } +BinaryenOp BinaryenNotVec128(void) { return NotVec128; } +BinaryenOp BinaryenAndVec128(void) { return AndVec128; } +BinaryenOp BinaryenOrVec128(void) { return OrVec128; } +BinaryenOp BinaryenXorVec128(void) { return XorVec128; } +BinaryenOp BinaryenAndNotVec128(void) { return AndNotVec128; } +BinaryenOp BinaryenBitselectVec128(void) { return Bitselect; } +BinaryenOp BinaryenAbsVecI8x16(void) { return AbsVecI8x16; } +BinaryenOp BinaryenNegVecI8x16(void) { return NegVecI8x16; } +BinaryenOp BinaryenAnyTrueVecI8x16(void) { return AnyTrueVecI8x16; } +BinaryenOp BinaryenAllTrueVecI8x16(void) { return AllTrueVecI8x16; } +BinaryenOp BinaryenBitmaskVecI8x16(void) { return BitmaskVecI8x16; } +BinaryenOp BinaryenShlVecI8x16(void) { return ShlVecI8x16; } +BinaryenOp BinaryenShrSVecI8x16(void) { return ShrSVecI8x16; } +BinaryenOp BinaryenShrUVecI8x16(void) { return ShrUVecI8x16; } +BinaryenOp BinaryenAddVecI8x16(void) { return AddVecI8x16; } +BinaryenOp BinaryenAddSatSVecI8x16(void) { return AddSatSVecI8x16; } +BinaryenOp BinaryenAddSatUVecI8x16(void) { return AddSatUVecI8x16; } +BinaryenOp BinaryenSubVecI8x16(void) { return SubVecI8x16; } +BinaryenOp BinaryenSubSatSVecI8x16(void) { return SubSatSVecI8x16; } +BinaryenOp BinaryenSubSatUVecI8x16(void) { return SubSatUVecI8x16; } +BinaryenOp BinaryenMulVecI8x16(void) { return MulVecI8x16; } +BinaryenOp BinaryenMinSVecI8x16(void) { return MinSVecI8x16; } +BinaryenOp BinaryenMinUVecI8x16(void) { return MinUVecI8x16; } +BinaryenOp BinaryenMaxSVecI8x16(void) { return MaxSVecI8x16; } +BinaryenOp BinaryenMaxUVecI8x16(void) { return MaxUVecI8x16; } +BinaryenOp BinaryenAvgrUVecI8x16(void) { return AvgrUVecI8x16; } +BinaryenOp BinaryenAbsVecI16x8(void) { return AbsVecI16x8; } +BinaryenOp BinaryenNegVecI16x8(void) { return NegVecI16x8; } +BinaryenOp BinaryenAnyTrueVecI16x8(void) { return AnyTrueVecI16x8; } +BinaryenOp BinaryenAllTrueVecI16x8(void) { return AllTrueVecI16x8; } +BinaryenOp BinaryenBitmaskVecI16x8(void) { return BitmaskVecI16x8; } +BinaryenOp BinaryenShlVecI16x8(void) { return ShlVecI16x8; } +BinaryenOp BinaryenShrSVecI16x8(void) { return ShrSVecI16x8; } +BinaryenOp BinaryenShrUVecI16x8(void) { return ShrUVecI16x8; } +BinaryenOp BinaryenAddVecI16x8(void) { return AddVecI16x8; } +BinaryenOp BinaryenAddSatSVecI16x8(void) { return AddSatSVecI16x8; } +BinaryenOp BinaryenAddSatUVecI16x8(void) { return AddSatUVecI16x8; } +BinaryenOp BinaryenSubVecI16x8(void) { return SubVecI16x8; } +BinaryenOp BinaryenSubSatSVecI16x8(void) { return SubSatSVecI16x8; } +BinaryenOp BinaryenSubSatUVecI16x8(void) { return SubSatUVecI16x8; } +BinaryenOp BinaryenMulVecI16x8(void) { return MulVecI16x8; } +BinaryenOp BinaryenMinSVecI16x8(void) { return MinSVecI16x8; } +BinaryenOp BinaryenMinUVecI16x8(void) { return MinUVecI16x8; } +BinaryenOp BinaryenMaxSVecI16x8(void) { return MaxSVecI16x8; } +BinaryenOp BinaryenMaxUVecI16x8(void) { return MaxUVecI16x8; } +BinaryenOp BinaryenAvgrUVecI16x8(void) { return AvgrUVecI16x8; } +BinaryenOp BinaryenAbsVecI32x4(void) { return AbsVecI32x4; } +BinaryenOp BinaryenNegVecI32x4(void) { return NegVecI32x4; } +BinaryenOp BinaryenAnyTrueVecI32x4(void) { return AnyTrueVecI32x4; } +BinaryenOp BinaryenAllTrueVecI32x4(void) { return AllTrueVecI32x4; } +BinaryenOp BinaryenBitmaskVecI32x4(void) { return BitmaskVecI32x4; } +BinaryenOp BinaryenShlVecI32x4(void) { return ShlVecI32x4; } +BinaryenOp BinaryenShrSVecI32x4(void) { return ShrSVecI32x4; } +BinaryenOp BinaryenShrUVecI32x4(void) { return ShrUVecI32x4; } +BinaryenOp BinaryenAddVecI32x4(void) { return AddVecI32x4; } +BinaryenOp BinaryenSubVecI32x4(void) { return SubVecI32x4; } +BinaryenOp BinaryenMulVecI32x4(void) { return MulVecI32x4; } +BinaryenOp BinaryenMinSVecI32x4(void) { return MinSVecI32x4; } +BinaryenOp BinaryenMinUVecI32x4(void) { return MinUVecI32x4; } +BinaryenOp BinaryenMaxSVecI32x4(void) { return MaxSVecI32x4; } +BinaryenOp BinaryenMaxUVecI32x4(void) { return MaxUVecI32x4; } +BinaryenOp BinaryenDotSVecI16x8ToVecI32x4(void) { + return DotSVecI16x8ToVecI32x4; +} +BinaryenOp BinaryenNegVecI64x2(void) { return NegVecI64x2; } +BinaryenOp BinaryenAnyTrueVecI64x2(void) { return AnyTrueVecI64x2; } +BinaryenOp BinaryenAllTrueVecI64x2(void) { return AllTrueVecI64x2; } +BinaryenOp BinaryenShlVecI64x2(void) { return ShlVecI64x2; } +BinaryenOp BinaryenShrSVecI64x2(void) { return ShrSVecI64x2; } +BinaryenOp BinaryenShrUVecI64x2(void) { return ShrUVecI64x2; } +BinaryenOp BinaryenAddVecI64x2(void) { return AddVecI64x2; } +BinaryenOp BinaryenSubVecI64x2(void) { return SubVecI64x2; } +BinaryenOp BinaryenMulVecI64x2(void) { return MulVecI64x2; } +BinaryenOp BinaryenAbsVecF32x4(void) { return AbsVecF32x4; } +BinaryenOp BinaryenNegVecF32x4(void) { return NegVecF32x4; } +BinaryenOp BinaryenSqrtVecF32x4(void) { return SqrtVecF32x4; } +BinaryenOp BinaryenQFMAVecF32x4(void) { return QFMAF32x4; } +BinaryenOp BinaryenQFMSVecF32x4(void) { return QFMSF32x4; } +BinaryenOp BinaryenAddVecF32x4(void) { return AddVecF32x4; } +BinaryenOp BinaryenSubVecF32x4(void) { return SubVecF32x4; } +BinaryenOp BinaryenMulVecF32x4(void) { return MulVecF32x4; } +BinaryenOp BinaryenDivVecF32x4(void) { return DivVecF32x4; } +BinaryenOp BinaryenMinVecF32x4(void) { return MinVecF32x4; } +BinaryenOp BinaryenMaxVecF32x4(void) { return MaxVecF32x4; } +BinaryenOp BinaryenPMinVecF32x4(void) { return PMinVecF32x4; } +BinaryenOp BinaryenCeilVecF32x4(void) { return CeilVecF32x4; } +BinaryenOp BinaryenFloorVecF32x4(void) { return FloorVecF32x4; } +BinaryenOp BinaryenTruncVecF32x4(void) { return TruncVecF32x4; } +BinaryenOp BinaryenNearestVecF32x4(void) { return NearestVecF32x4; } +BinaryenOp BinaryenPMaxVecF32x4(void) { return PMaxVecF32x4; } +BinaryenOp BinaryenAbsVecF64x2(void) { return AbsVecF64x2; } +BinaryenOp BinaryenNegVecF64x2(void) { return NegVecF64x2; } +BinaryenOp BinaryenSqrtVecF64x2(void) { return SqrtVecF64x2; } +BinaryenOp BinaryenQFMAVecF64x2(void) { return QFMAF64x2; } +BinaryenOp BinaryenQFMSVecF64x2(void) { return QFMSF64x2; } +BinaryenOp BinaryenAddVecF64x2(void) { return AddVecF64x2; } +BinaryenOp BinaryenSubVecF64x2(void) { return SubVecF64x2; } +BinaryenOp BinaryenMulVecF64x2(void) { return MulVecF64x2; } +BinaryenOp BinaryenDivVecF64x2(void) { return DivVecF64x2; } +BinaryenOp BinaryenMinVecF64x2(void) { return MinVecF64x2; } +BinaryenOp BinaryenMaxVecF64x2(void) { return MaxVecF64x2; } +BinaryenOp BinaryenPMinVecF64x2(void) { return PMinVecF64x2; } +BinaryenOp BinaryenPMaxVecF64x2(void) { return PMaxVecF64x2; } +BinaryenOp BinaryenCeilVecF64x2(void) { return CeilVecF64x2; } +BinaryenOp BinaryenFloorVecF64x2(void) { return FloorVecF64x2; } +BinaryenOp BinaryenTruncVecF64x2(void) { return TruncVecF64x2; } +BinaryenOp BinaryenNearestVecF64x2(void) { return NearestVecF64x2; } +BinaryenOp BinaryenTruncSatSVecF32x4ToVecI32x4(void) { + return TruncSatSVecF32x4ToVecI32x4; +} +BinaryenOp BinaryenTruncSatUVecF32x4ToVecI32x4(void) { + return TruncSatUVecF32x4ToVecI32x4; +} +BinaryenOp BinaryenTruncSatSVecF64x2ToVecI64x2(void) { + return TruncSatSVecF64x2ToVecI64x2; +} +BinaryenOp BinaryenTruncSatUVecF64x2ToVecI64x2(void) { + return TruncSatUVecF64x2ToVecI64x2; +} +BinaryenOp BinaryenConvertSVecI32x4ToVecF32x4(void) { + return ConvertSVecI32x4ToVecF32x4; +} +BinaryenOp BinaryenConvertUVecI32x4ToVecF32x4(void) { + return ConvertUVecI32x4ToVecF32x4; +} +BinaryenOp BinaryenConvertSVecI64x2ToVecF64x2(void) { + return ConvertSVecI64x2ToVecF64x2; +} +BinaryenOp BinaryenConvertUVecI64x2ToVecF64x2(void) { + return ConvertUVecI64x2ToVecF64x2; +} +BinaryenOp BinaryenLoadSplatVec8x16(void) { return LoadSplatVec8x16; } +BinaryenOp BinaryenLoadSplatVec16x8(void) { return LoadSplatVec16x8; } +BinaryenOp BinaryenLoadSplatVec32x4(void) { return LoadSplatVec32x4; } +BinaryenOp BinaryenLoadSplatVec64x2(void) { return LoadSplatVec64x2; } +BinaryenOp BinaryenLoadExtSVec8x8ToVecI16x8(void) { + return LoadExtSVec8x8ToVecI16x8; +} +BinaryenOp BinaryenLoadExtUVec8x8ToVecI16x8(void) { + return LoadExtUVec8x8ToVecI16x8; +} +BinaryenOp BinaryenLoadExtSVec16x4ToVecI32x4(void) { + return LoadExtSVec16x4ToVecI32x4; +} +BinaryenOp BinaryenLoadExtUVec16x4ToVecI32x4(void) { + return LoadExtUVec16x4ToVecI32x4; +} +BinaryenOp BinaryenLoadExtSVec32x2ToVecI64x2(void) { + return LoadExtSVec32x2ToVecI64x2; +} +BinaryenOp BinaryenLoadExtUVec32x2ToVecI64x2(void) { + return LoadExtUVec32x2ToVecI64x2; +} +BinaryenOp BinaryenNarrowSVecI16x8ToVecI8x16(void) { + return NarrowSVecI16x8ToVecI8x16; +} +BinaryenOp BinaryenNarrowUVecI16x8ToVecI8x16(void) { + return NarrowUVecI16x8ToVecI8x16; +} +BinaryenOp BinaryenNarrowSVecI32x4ToVecI16x8(void) { + return NarrowSVecI32x4ToVecI16x8; +} +BinaryenOp BinaryenNarrowUVecI32x4ToVecI16x8(void) { + return NarrowUVecI32x4ToVecI16x8; +} +BinaryenOp BinaryenWidenLowSVecI8x16ToVecI16x8(void) { + return WidenLowSVecI8x16ToVecI16x8; +} +BinaryenOp BinaryenWidenHighSVecI8x16ToVecI16x8(void) { + return WidenHighSVecI8x16ToVecI16x8; +} +BinaryenOp BinaryenWidenLowUVecI8x16ToVecI16x8(void) { + return WidenLowUVecI8x16ToVecI16x8; +} +BinaryenOp BinaryenWidenHighUVecI8x16ToVecI16x8(void) { + return WidenHighUVecI8x16ToVecI16x8; +} +BinaryenOp BinaryenWidenLowSVecI16x8ToVecI32x4(void) { + return WidenLowSVecI16x8ToVecI32x4; +} +BinaryenOp BinaryenWidenHighSVecI16x8ToVecI32x4(void) { + return WidenHighSVecI16x8ToVecI32x4; +} +BinaryenOp BinaryenWidenLowUVecI16x8ToVecI32x4(void) { + return WidenLowUVecI16x8ToVecI32x4; +} +BinaryenOp BinaryenWidenHighUVecI16x8ToVecI32x4(void) { + return WidenHighUVecI16x8ToVecI32x4; +} +BinaryenOp BinaryenSwizzleVec8x16(void) { return SwizzleVec8x16; } + +BinaryenExpressionRef BinaryenBlock(BinaryenModuleRef module, + const char* name, + BinaryenExpressionRef* children, + BinaryenIndex numChildren, + BinaryenType type) { + auto* ret = ((Module*)module)->allocator.alloc(); + if (name) { + ret->name = name; + } + for (BinaryenIndex i = 0; i < numChildren; i++) { + ret->list.push_back((Expression*)children[i]); + } + if (type != BinaryenTypeAuto()) { + ret->finalize(Type(type)); + } else { + ret->finalize(); + } + return static_cast(ret); +} +BinaryenExpressionRef BinaryenIf(BinaryenModuleRef module, + BinaryenExpressionRef condition, + BinaryenExpressionRef ifTrue, + BinaryenExpressionRef ifFalse) { + auto* ret = ((Module*)module)->allocator.alloc(); + ret->condition = (Expression*)condition; + ret->ifTrue = (Expression*)ifTrue; + ret->ifFalse = (Expression*)ifFalse; + ret->finalize(); + return static_cast(ret); +} +BinaryenExpressionRef BinaryenLoop(BinaryenModuleRef module, + const char* name, + BinaryenExpressionRef body) { + return static_cast( + Builder(*(Module*)module) + .makeLoop(name ? Name(name) : Name(), (Expression*)body)); +} +BinaryenExpressionRef BinaryenBreak(BinaryenModuleRef module, + const char* name, + BinaryenExpressionRef condition, + BinaryenExpressionRef value) { + return static_cast( + Builder(*(Module*)module) + .makeBreak(name, (Expression*)value, (Expression*)condition)); +} +BinaryenExpressionRef BinaryenSwitch(BinaryenModuleRef module, + const char** names, + BinaryenIndex numNames, + const char* defaultName, + BinaryenExpressionRef condition, + BinaryenExpressionRef value) { + auto* ret = ((Module*)module)->allocator.alloc(); + for (BinaryenIndex i = 0; i < numNames; i++) { + ret->targets.push_back(names[i]); + } + ret->default_ = defaultName; + ret->condition = (Expression*)condition; + ret->value = (Expression*)value; + ret->finalize(); + return static_cast(ret); +} +static BinaryenExpressionRef makeBinaryenCall(BinaryenModuleRef module, + const char* target, + BinaryenExpressionRef* operands, + BinaryenIndex numOperands, + BinaryenType returnType, + bool isReturn) { + auto* ret = ((Module*)module)->allocator.alloc(); + ret->target = target; + for (BinaryenIndex i = 0; i < numOperands; i++) { + ret->operands.push_back((Expression*)operands[i]); + } + ret->type = Type(returnType); + ret->isReturn = isReturn; + ret->finalize(); + return static_cast(ret); +} +BinaryenExpressionRef BinaryenCall(BinaryenModuleRef module, + const char* target, + BinaryenExpressionRef* operands, + BinaryenIndex numOperands, + BinaryenType returnType) { + return makeBinaryenCall( + module, target, operands, numOperands, returnType, false); +} +BinaryenExpressionRef BinaryenReturnCall(BinaryenModuleRef module, + const char* target, + BinaryenExpressionRef* operands, + BinaryenIndex numOperands, + BinaryenType returnType) { + return makeBinaryenCall( + module, target, operands, numOperands, returnType, true); +} +static BinaryenExpressionRef +makeBinaryenCallIndirect(BinaryenModuleRef module, + BinaryenExpressionRef target, + BinaryenExpressionRef* operands, + BinaryenIndex numOperands, + BinaryenType params, + BinaryenType results, + bool isReturn) { + auto* ret = ((Module*)module)->allocator.alloc(); + ret->target = (Expression*)target; + for (BinaryenIndex i = 0; i < numOperands; i++) { + ret->operands.push_back((Expression*)operands[i]); + } + ret->sig = Signature(Type(params), Type(results)); + ret->type = Type(results); + ret->isReturn = isReturn; + ret->finalize(); + return static_cast(ret); +} +BinaryenExpressionRef BinaryenCallIndirect(BinaryenModuleRef module, + BinaryenExpressionRef target, + BinaryenExpressionRef* operands, + BinaryenIndex numOperands, + BinaryenType params, + BinaryenType results) { + return makeBinaryenCallIndirect( + module, target, operands, numOperands, params, results, false); +} +BinaryenExpressionRef +BinaryenReturnCallIndirect(BinaryenModuleRef module, + BinaryenExpressionRef target, + BinaryenExpressionRef* operands, + BinaryenIndex numOperands, + BinaryenType params, + BinaryenType results) { + return makeBinaryenCallIndirect( + module, target, operands, numOperands, params, results, true); +} +BinaryenExpressionRef BinaryenLocalGet(BinaryenModuleRef module, + BinaryenIndex index, + BinaryenType type) { + auto* ret = ((Module*)module)->allocator.alloc(); + ret->index = index; + ret->type = Type(type); + ret->finalize(); + return static_cast(ret); +} +BinaryenExpressionRef BinaryenLocalSet(BinaryenModuleRef module, + BinaryenIndex index, + BinaryenExpressionRef value) { + auto* ret = ((Module*)module)->allocator.alloc(); + ret->index = index; + ret->value = (Expression*)value; + ret->makeSet(); + ret->finalize(); + return static_cast(ret); +} +BinaryenExpressionRef BinaryenLocalTee(BinaryenModuleRef module, + BinaryenIndex index, + BinaryenExpressionRef value, + BinaryenType type) { + auto* ret = ((Module*)module)->allocator.alloc(); + ret->index = index; + ret->value = (Expression*)value; + ret->makeTee(Type(type)); + ret->finalize(); + return static_cast(ret); +} +BinaryenExpressionRef BinaryenGlobalGet(BinaryenModuleRef module, + const char* name, + BinaryenType type) { + auto* ret = ((Module*)module)->allocator.alloc(); + ret->name = name; + ret->type = Type(type); + ret->finalize(); + return static_cast(ret); +} +BinaryenExpressionRef BinaryenGlobalSet(BinaryenModuleRef module, + const char* name, + BinaryenExpressionRef value) { + auto* ret = ((Module*)module)->allocator.alloc(); + ret->name = name; + ret->value = (Expression*)value; + ret->finalize(); + return static_cast(ret); +} +BinaryenExpressionRef BinaryenLoad(BinaryenModuleRef module, + uint32_t bytes, + int8_t signed_, + uint32_t offset, + uint32_t align, + BinaryenType type, + BinaryenExpressionRef ptr) { + auto* ret = ((Module*)module)->allocator.alloc(); + ret->isAtomic = false; + ret->bytes = bytes; + ret->signed_ = !!signed_; + ret->offset = offset; + ret->align = align ? align : bytes; + ret->type = Type(type); + ret->ptr = (Expression*)ptr; + ret->finalize(); + return static_cast(ret); +} +BinaryenExpressionRef BinaryenStore(BinaryenModuleRef module, + uint32_t bytes, + uint32_t offset, + uint32_t align, + BinaryenExpressionRef ptr, + BinaryenExpressionRef value, + BinaryenType type) { + auto* ret = ((Module*)module)->allocator.alloc(); + ret->isAtomic = false; + ret->bytes = bytes; + ret->offset = offset; + ret->align = align ? align : bytes; + ret->ptr = (Expression*)ptr; + ret->value = (Expression*)value; + ret->valueType = Type(type); + ret->finalize(); + return static_cast(ret); +} +BinaryenExpressionRef BinaryenConst(BinaryenModuleRef module, + BinaryenLiteral value) { + return static_cast( + Builder(*(Module*)module).makeConst(fromBinaryenLiteral(value))); +} +BinaryenExpressionRef BinaryenUnary(BinaryenModuleRef module, + BinaryenOp op, + BinaryenExpressionRef value) { + return static_cast( + Builder(*(Module*)module).makeUnary(UnaryOp(op), (Expression*)value)); +} +BinaryenExpressionRef BinaryenBinary(BinaryenModuleRef module, + BinaryenOp op, + BinaryenExpressionRef left, + BinaryenExpressionRef right) { + return static_cast( + Builder(*(Module*)module) + .makeBinary(BinaryOp(op), (Expression*)left, (Expression*)right)); +} +BinaryenExpressionRef BinaryenSelect(BinaryenModuleRef module, + BinaryenExpressionRef condition, + BinaryenExpressionRef ifTrue, + BinaryenExpressionRef ifFalse, + BinaryenType type) { + auto* ret = ((Module*)module)->allocator.alloc()); + return static_cast(expression)->ifTrue; +} +void BinaryenSelectSetIfTrue(BinaryenExpressionRef expr, + BinaryenExpressionRef ifTrueExpr) { + auto* expression = (Expression*)expr; + assert(expression->is()); + return static_cast(expression)->ifFalse; +} +void BinaryenSelectSetIfFalse(BinaryenExpressionRef expr, + BinaryenExpressionRef ifFalseExpr) { + auto* expression = (Expression*)expr; + assert(expression->is()); + return static_cast(expression)->condition; +} +void BinaryenSelectSetCondition(BinaryenExpressionRef expr, + BinaryenExpressionRef condExpr) { + auto* expression = (Expression*)expr; + assert(expression->is()) { + return doVisitSelect(select); + } else if (auto* unreachable = curr->dynCast()) { + return doVisitUnreachable(unreachable); + } else if (auto* drop = curr->dynCast()) { + return doVisitDrop(drop); + } else if (curr->is() || curr->is() || curr->is() || + curr->is()) { + Fatal() << "DataFlow does not support EH instructions yet"; + } else { + return doVisitGeneric(curr); + } + } + + Node* doVisitBlock(Block* curr) { + // TODO: handle super-deep nesting + auto* oldParent = parent; + expressionParentMap[curr] = oldParent; + parent = curr; + for (auto* child : curr->list) { + visit(child); + } + // Merge the outputs + // TODO handle conditions on these breaks + if (curr->name.is()) { + auto iter = breakStates.find(curr->name); + if (iter != breakStates.end()) { + auto& states = iter->second; + // Add the state flowing out + if (!isInUnreachable()) { + states.push_back(locals); + } + mergeBlock(states, locals); + } + } + parent = oldParent; + return &bad; + } + Node* doVisitIf(If* curr) { + auto* oldParent = parent; + expressionParentMap[curr] = oldParent; + parent = curr; + // Set up the condition. + Node* condition = visit(curr->condition); + assert(condition); + // Handle the contents. + auto initialState = locals; + visit(curr->ifTrue); + auto afterIfTrueState = locals; + if (curr->ifFalse) { + locals = initialState; + visit(curr->ifFalse); + auto afterIfFalseState = locals; // TODO: optimize + mergeIf(afterIfTrueState, afterIfFalseState, condition, curr, locals); + } else { + mergeIf(initialState, afterIfTrueState, condition, curr, locals); + } + parent = oldParent; + return &bad; + } + Node* doVisitLoop(Loop* curr) { + auto* oldParent = parent; + expressionParentMap[curr] = oldParent; + parent = curr; + // As in Souper's LLVM extractor, we avoid loop phis, as we don't want + // our traces to represent a value that differs across loop iterations. + // For example, + // %b = block + // %x = phi %b, 1, %y + // %y = phi %b, 2, %x + // %z = eq %x %y + // infer %z + // Here %y refers to the previous iteration's %x. + // To do this, we set all locals to a Var at the loop entry, then process + // the inside of the loop. When that is done, we can see if a phi was + // actually needed for each local. If it was, we leave the Var (it + // represents an unknown value; analysis stops there), and if not, we + // can replace the Var with the fixed value. + // TODO: perhaps some more general uses of DataFlow will want loop phis? + // TODO: optimize stuff here + if (isInUnreachable()) { + return &bad; // none of this matters + } + if (!curr->name.is()) { + visit(curr->body); + return &bad; // no phis are possible + } + auto previous = locals; + auto numLocals = func->getNumLocals(); + for (Index i = 0; i < numLocals; i++) { + locals[i] = makeVar(func->getLocalType(i)); + } + auto vars = locals; // all the Vars we just created + // We may need to replace values later - only new nodes added from + // here are relevant. + auto firstNodeFromLoop = nodes.size(); + // Process the loop body. + visit(curr->body); + // Find all incoming paths. + auto& breaks = breakStates[curr->name]; + // Phis are possible, check for them. + for (Index i = 0; i < numLocals; i++) { + if (!isRelevantType(func->getLocalType(i))) { + continue; + } + bool needPhi = false; + // We replaced the proper value with a Var. If it's still that + // Var - or it's the original proper value, which can happen with + // constants - on all incoming paths, then a phi is not needed. + auto* var = vars[i]; + auto* proper = previous[i]; + for (auto& other : breaks) { + assert(!isInUnreachable(other)); + auto& curr = *(other[i]); + if (curr != *var && curr != *proper) { + // A phi would be necessary here. + needPhi = true; + break; + } + } + if (needPhi) { + // Nothing to do - leave the Vars, the loop phis are + // unknown values to us. + } else { + // Undo the Var for this local: In every new node added for + // the loop body, replace references to the Var with the + // previous value (the value that is all we need instead of a phi). + for (auto j = firstNodeFromLoop; j < nodes.size(); j++) { + for (auto*& value : nodes[j].get()->values) { + if (value == var) { + value = proper; + } + } + } + // Also undo in the current local state, which is flowing out + // of the loop. + for (auto*& node : locals) { + if (node == var) { + node = proper; + } + } + } + } + return &bad; + } + Node* doVisitBreak(Break* curr) { + if (!isInUnreachable()) { + breakStates[curr->name].push_back(locals); + } + if (!curr->condition) { + setInUnreachable(); + } else { + visit(curr->condition); + } + return &bad; + } + Node* doVisitSwitch(Switch* curr) { + visit(curr->condition); + if (!isInUnreachable()) { + std::unordered_set targets; + for (auto target : curr->targets) { + targets.insert(target); + } + targets.insert(curr->default_); + for (auto target : targets) { + breakStates[target].push_back(locals); + } + } + setInUnreachable(); + return &bad; + } + Node* doVisitLocalGet(LocalGet* curr) { + if (!isRelevantLocal(curr->index) || isInUnreachable()) { + return &bad; + } + // We now know which IR node this get refers to + auto* node = locals[curr->index]; + return node; + } + Node* doVisitLocalSet(LocalSet* curr) { + if (!isRelevantLocal(curr->index) || isInUnreachable()) { + return &bad; + } + assert(curr->value->type.isConcrete()); + sets.push_back(curr); + expressionParentMap[curr] = parent; + expressionParentMap[curr->value] = curr; + // Set the current node in the local state. + auto* node = visit(curr->value); + locals[curr->index] = setNodeMap[curr] = node; + // If we created a new node (and not just did a get of a set, which + // passes around an existing node), mark its parent. + if (nodeParentMap.find(node) == nodeParentMap.end()) { + nodeParentMap[node] = curr; + } + return &bad; + } + Node* doVisitConst(Const* curr) { return makeConst(curr->value); } + Node* doVisitUnary(Unary* curr) { + // First, check if we support this op. + switch (curr->op) { + case ClzInt32: + case ClzInt64: + case CtzInt32: + case CtzInt64: + case PopcntInt32: + case PopcntInt64: { + // These are ok as-is. + // Check if our child is supported. + auto* value = expandFromI1(visit(curr->value), curr); + if (value->isBad()) { + return value; + } + // Great, we are supported! + auto* ret = addNode(Node::makeExpr(curr, curr)); + ret->addValue(value); + return ret; + } + case EqZInt32: + case EqZInt64: { + // These can be implemented using a binary. + // Check if our child is supported. + auto* value = expandFromI1(visit(curr->value), curr); + if (value->isBad()) { + return value; + } + // Great, we are supported! + return makeZeroComp(value, true, curr); + } + default: { + // Anything else is an unknown value. + return makeVar(curr->type); + } + } + } + Node* doVisitBinary(Binary* curr) { + // First, check if we support this op. + switch (curr->op) { + case AddInt32: + case AddInt64: + case SubInt32: + case SubInt64: + case MulInt32: + case MulInt64: + case DivSInt32: + case DivSInt64: + case DivUInt32: + case DivUInt64: + case RemSInt32: + case RemSInt64: + case RemUInt32: + case RemUInt64: + case AndInt32: + case AndInt64: + case OrInt32: + case OrInt64: + case XorInt32: + case XorInt64: + case ShlInt32: + case ShlInt64: + case ShrUInt32: + case ShrUInt64: + case ShrSInt32: + case ShrSInt64: + case RotLInt32: + case RotLInt64: + case RotRInt32: + case RotRInt64: + case EqInt32: + case EqInt64: + case NeInt32: + case NeInt64: + case LtSInt32: + case LtSInt64: + case LtUInt32: + case LtUInt64: + case LeSInt32: + case LeSInt64: + case LeUInt32: + case LeUInt64: { + // These are ok as-is. + // Check if our children are supported. + auto* left = expandFromI1(visit(curr->left), curr); + if (left->isBad()) { + return left; + } + auto* right = expandFromI1(visit(curr->right), curr); + if (right->isBad()) { + return right; + } + // Great, we are supported! + auto* ret = addNode(Node::makeExpr(curr, curr)); + ret->addValue(left); + ret->addValue(right); + return ret; + } + case GtSInt32: + case GtSInt64: + case GeSInt32: + case GeSInt64: + case GtUInt32: + case GtUInt64: + case GeUInt32: + case GeUInt64: { + // These need to be flipped as Souper does not support redundant ops. + Builder builder(*module); + BinaryOp opposite; + switch (curr->op) { + case GtSInt32: + opposite = LtSInt32; + break; + case GtSInt64: + opposite = LtSInt64; + break; + case GeSInt32: + opposite = LeSInt32; + break; + case GeSInt64: + opposite = LeSInt64; + break; + case GtUInt32: + opposite = LtUInt32; + break; + case GtUInt64: + opposite = LtUInt64; + break; + case GeUInt32: + opposite = LeUInt32; + break; + case GeUInt64: + opposite = LeUInt64; + break; + default: + WASM_UNREACHABLE("unexpected op"); + } + auto* ret = + visitBinary(builder.makeBinary(opposite, curr->right, curr->left)); + // We just created a new binary node, but we need to set the origin + // properly to the original. + ret->origin = curr; + return ret; + } + default: { + // Anything else is an unknown value. + return makeVar(curr->type); + } + } + } + Node* doVisitSelect(Select* curr) { + auto* ifTrue = expandFromI1(visit(curr->ifTrue), curr); + if (ifTrue->isBad()) { + return ifTrue; + } + auto* ifFalse = expandFromI1(visit(curr->ifFalse), curr); + if (ifFalse->isBad()) { + return ifFalse; + } + auto* condition = ensureI1(visit(curr->condition), curr); + if (condition->isBad()) { + return condition; + } + // Great, we are supported! + auto* ret = addNode(Node::makeExpr(curr, curr)); + ret->addValue(condition); + ret->addValue(ifTrue); + ret->addValue(ifFalse); + return ret; + } + Node* doVisitUnreachable(Unreachable* curr) { + setInUnreachable(); + return &bad; + } + Node* doVisitDrop(Drop* curr) { + visit(curr->value); + // We need to know that the value's parent is a drop, indicating + // the value is not actually used here. + expressionParentMap[curr->value] = curr; + return &bad; + } + Node* doVisitGeneric(Expression* curr) { + // Just need to visit the nodes so we note all the gets + for (auto* child : ChildIterator(curr)) { + visit(child); + } + return makeVar(curr->type); + } + + // Helpers. + + bool isRelevantType(wasm::Type type) { return type.isInteger(); } + + bool isRelevantLocal(Index index) { + return isRelevantType(func->getLocalType(index)); + } + + // Merge local state for an if, also creating a block and conditions. + void mergeIf(Locals& aState, + Locals& bState, + Node* condition, + Expression* expr, + Locals& out) { + // Create the conditions (if we can). + Node* ifTrue; + Node* ifFalse; + if (!condition->isBad()) { + // Generate boolean (i1 returning) conditions for the two branches. + auto& conditions = expressionConditionMap[expr]; + ifTrue = ensureI1(condition, nullptr); + conditions.push_back(ifTrue); + ifFalse = makeZeroComp(condition, true, nullptr); + conditions.push_back(ifFalse); + } else { + ifTrue = ifFalse = &bad; + } + // Finally, merge the state with that block. TODO optimize + std::vector states; + if (!isInUnreachable(aState)) { + states.emplace_back(aState, ifTrue); + } + if (!isInUnreachable(bState)) { + states.emplace_back(bState, ifFalse); + } + merge(states, out); + } + + // Merge local state for a block + void mergeBlock(std::vector& localses, Locals& out) { + // TODO: conditions + std::vector states; + for (auto& locals : localses) { + states.emplace_back(locals, &bad); + } + merge(states, out); + } + + // Merge local state for multiple control flow paths, creating phis as needed. + void merge(std::vector& states, Locals& out) { + // We should only receive reachable states. +#ifndef NDEBUG + for (auto& state : states) { + assert(!isInUnreachable(state.locals)); + } +#endif + Index numStates = states.size(); + if (numStates == 0) { + // We were unreachable, and still are. + assert(isInUnreachable()); + return; + } + // We may have just become reachable, if we were not before. + setInReachable(); + // Just one thing to merge is trivial. + if (numStates == 1) { + out = states[0].locals; + return; + } + // We create a block if we need one. + Index numLocals = func->getNumLocals(); + Node* block = nullptr; + for (Index i = 0; i < numLocals; i++) { + if (!isRelevantType(func->getLocalType(i))) { + continue; + } + // Process the inputs. If any is bad, the phi is bad. + bool bad = false; + for (auto& state : states) { + auto* node = state.locals[i]; + if (node->isBad()) { + bad = true; + out[i] = node; + break; + } + } + if (bad) { + continue; + } + // Nothing is bad, proceed. + Node* first = nullptr; + for (auto& state : states) { + if (!first) { + first = out[i] = state.locals[i]; + } else if (state.locals[i] != first) { + // We need to actually merge some stuff. + if (!block) { + block = addNode(Node::makeBlock()); + for (Index index = 0; index < numStates; index++) { + auto* condition = states[index].condition; + if (!condition->isBad()) { + condition = addNode(Node::makeCond(block, index, condition)); + } + block->addValue(condition); + } + } + auto* phi = addNode(Node::makePhi(block, i)); + for (auto& state : states) { + auto* value = expandFromI1(state.locals[i], nullptr); + phi->addValue(value); + } + out[i] = phi; + break; + } + } + } + } + + // If the node returns an i1, then we are called from a context that needs + // to use it normally as in wasm - extend it + Node* expandFromI1(Node* node, Expression* origin) { + if (!node->isBad() && node->returnsI1()) { + node = addNode(Node::makeZext(node, origin)); + } + return node; + } + + Node* ensureI1(Node* node, Expression* origin) { + if (!node->isBad() && !node->returnsI1()) { + node = makeZeroComp(node, false, origin); + } + return node; + } + + // Given a node representing something that is local.set'd, return + // the set. + LocalSet* getSet(Node* node) { + auto iter = nodeParentMap.find(node); + if (iter == nodeParentMap.end()) { + return nullptr; + } + return iter->second->dynCast(); + } + + // Given an expression, return the parent if such exists. + Expression* getParent(Expression* curr) { + auto iter = expressionParentMap.find(curr); + if (iter == expressionParentMap.end()) { + return nullptr; + } + return iter->second; + } + + // Given an expression, return the set for it if such exists. + LocalSet* getSet(Expression* curr) { + auto* parent = getParent(curr); + return parent ? parent->dynCast() : nullptr; + } + + // Creates an expression that uses a node. Generally, a node represents + // a value in a local, so we create a local.get for it. + Expression* makeUse(Node* node) { + Builder builder(*module); + if (node->isPhi()) { + // The index is the wasm local that we assign to when implementing + // the phi; get from there. + auto index = node->index; + return builder.makeLocalGet(index, func->getLocalType(index)); + } else if (node->isConst()) { + return builder.makeConst(node->expr->cast()->value); + } else if (node->isExpr()) { + // Find the set we are a value of. + auto index = getSet(node)->index; + return builder.makeLocalGet(index, func->getLocalType(index)); + } else if (node->isZext()) { + // i1 zexts are a no-op for wasm + return makeUse(node->values[0]); + } else if (node->isVar()) { + // Nothing valid for us to read here. Emit a call, representing an unknown + // variable value. + return Builder(*module).makeCall(FAKE_CALL, {}, node->wasmType); + } else { + WASM_UNREACHABLE("unexpected node type"); // TODO + } + } + + const Name FAKE_CALL = "fake$dfo$call"; +}; + +} // namespace DataFlow + +} // namespace wasm + +#endif // wasm_dataflow_graph_h diff --git a/binaryen/src/dataflow/node.h b/binaryen/src/dataflow/node.h new file mode 100644 --- /dev/null +++ b/binaryen/src/dataflow/node.h @@ -0,0 +1,223 @@ +/* + * Copyright 2018 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// DataFlow IR is an SSA representation. It can be built from the main +// Binaryen IR. +// +// THe main initial use case was an IR that could easily be converted to +// Souper IR, and the design favors that. +// + +#ifndef wasm_dataflow_node_h +#define wasm_dataflow_node_h + +#include "ir/utils.h" +#include "wasm.h" + +namespace wasm { + +namespace DataFlow { + +// +// The core IR representation in DataFlow: a Node. +// +// We reuse the Binaryen IR as much as possible: when things are identical +// between the two IRs, we just create an Expr node, which stores the opcode and +// other details, and we can emit them to Souper by reading the Binaryen +// Expression. Other node types here are special things from Souper IR that we +// can't represent that way. +// +// * Souper comparisons return an i1. We extend them immediately if they are +// going to be used as i32s or i64s. +// * When we use an Expression node, we just use its immediate fields, like the +// op in a binary, alignment etc. in a load, etc. We don't look into the +// pointers to child nodes. Instead, the DataFlow IR has its own pointers +// directly to DataFlow children. In particular, this means that it's easy +// to create an Expression with the info you need and not care about linking +// it up to other Expressions. +// + +struct Node { + enum Type { + Var, // an unknown variable number (not to be confused with var/param/local + // in wasm) + Expr, // a value represented by a Binaryen Expression + Phi, // a phi from converging control flow + Cond, // a blockpc, representing one of the branchs for a Block + Block, // a source of phis + Zext, // zero-extend an i1 (from an op where Souper returns i1 but wasm does + // not, and so we need a special way to get back to an i32/i64 if we + // operate on that value instead of just passing it straight to + // Souper). + Bad // something we can't handle and should ignore + } type; + + Node(Type type) : type(type) {} + + // TODO: the others, if we need them + bool isVar() { return type == Var; } + bool isExpr() { return type == Expr; } + bool isPhi() { return type == Phi; } + bool isCond() { return type == Cond; } + bool isBlock() { return type == Block; } + bool isZext() { return type == Zext; } + bool isBad() { return type == Bad; } + + bool isConst() { return type == Expr && expr->is(); } + + union { + // For Var + wasm::Type wasmType; + // For Expr + Expression* expr; + // For Phi and Cond (the local index for phi, the block + // index for cond) + Index index; + }; + + // The wasm expression that we originate from (if such exists). A single + // wasm instruction may be turned into multiple dataflow IR nodes, and some + // nodes have no wasm origin (like phis). + Expression* origin = nullptr; + + // Extra list of related nodes. + // For Expr, these are the Nodes for the inputs to the expression (e.g. + // a binary would have 2 in this vector here). + // For Phi, this is the block and then the list of values to pick from. + // For Cond, this is the block and node. + // For Block, this is the list of Conds. Note that that block does not + // depend on them - the Phis do, but we store them in the block so that + // we can avoid duplication. + // For Zext, this is the value we extend. + std::vector values; + + // Constructors + static Node* makeVar(wasm::Type wasmType) { + Node* ret = new Node(Var); + ret->wasmType = wasmType; + return ret; + } + static Node* makeExpr(Expression* expr, Expression* origin) { + Node* ret = new Node(Expr); + ret->expr = expr; + ret->origin = origin; + return ret; + } + static Node* makePhi(Node* block, Index index) { + Node* ret = new Node(Phi); + ret->addValue(block); + ret->index = index; + return ret; + } + static Node* makeCond(Node* block, Index index, Node* node) { + Node* ret = new Node(Cond); + ret->addValue(block); + ret->index = index; + ret->addValue(node); + return ret; + } + static Node* makeBlock() { + Node* ret = new Node(Block); + return ret; + } + static Node* makeZext(Node* child, Expression* origin) { + Node* ret = new Node(Zext); + ret->addValue(child); + ret->origin = origin; + return ret; + } + static Node* makeBad() { + Node* ret = new Node(Bad); + return ret; + } + + // Helpers + + void addValue(Node* value) { values.push_back(value); } + Node* getValue(Index i) { return values.at(i); } + + // Gets the wasm type of the node. If there isn't a valid one, + // return unreachable. + wasm::Type getWasmType() { + switch (type) { + case Var: + return wasmType; + case Expr: + return expr->type; + case Phi: + return getValue(1)->getWasmType(); + case Zext: + return getValue(0)->getWasmType(); + case Bad: + return wasm::Type::unreachable; + default: + WASM_UNREACHABLE("invalid node type"); + } + } + + bool operator==(const Node& other) { + if (type != other.type) { + return false; + } + switch (type) { + case Var: + case Block: + return this == &other; + case Expr: { + if (!ExpressionAnalyzer::equal(expr, other.expr)) { + return false; + } + break; + } + case Cond: + if (index != other.index) { + return false; + } + default: {} + } + if (values.size() != other.values.size()) { + return false; + } + for (Index i = 0; i < values.size(); i++) { + if (*(values[i]) != *(other.values[i])) { + return false; + } + } + return true; + } + + bool operator!=(const Node& other) { return !(*this == other); } + + // As mentioned above, comparisons return i1. This checks + // if an operation is of that sort. + bool returnsI1() { + if (isExpr()) { + if (auto* binary = expr->dynCast()) { + return binary->isRelational(); + } else if (auto* unary = expr->dynCast()) { + return unary->isRelational(); + } + } + return false; + } +}; + +} // namespace DataFlow + +} // namespace wasm + +#endif // wasm_dataflow_node diff --git a/binaryen/src/dataflow/users.h b/binaryen/src/dataflow/users.h new file mode 100644 --- /dev/null +++ b/binaryen/src/dataflow/users.h @@ -0,0 +1,102 @@ +/* + * Copyright 2018 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// DataFlow IR is an SSA representation. It can be built from the main +// Binaryen IR. +// +// THe main initial use case was an IR that could easily be converted to +// Souper IR, and the design favors that. +// + +#ifndef wasm_dataflow_users_h +#define wasm_dataflow_users_h + +#include "dataflow/graph.h" + +namespace wasm { + +namespace DataFlow { + +// Calculates the users of each node. +// users[x] = { y, z, .. } +// where y, z etc. are nodes that use x, that is, x is in their +// values vector. +class Users { + typedef std::unordered_set UserSet; + + std::unordered_map users; + +public: + void build(Graph& graph) { + for (auto& node : graph.nodes) { + for (auto* value : node->values) { + users[value].insert(node.get()); + } + } + } + + UserSet& getUsers(Node* node) { + auto iter = users.find(node); + if (iter == users.end()) { + static UserSet empty; // FIXME thread_local? + return empty; + } + return iter->second; + } + + Index getNumUses(Node* node) { + auto& users = getUsers(node); + // A user may have more than one use + Index numUses = 0; + for (auto* user : users) { +#ifndef NDEBUG + bool found = false; +#endif + for (auto* value : user->values) { + if (value == node) { + numUses++; +#ifndef NDEBUG + found = true; +#endif + } + } + assert(found); + } + return numUses; + } + + // Stops using all the values of this node. Called when a node is being + // removed. + void stopUsingValues(Node* node) { + for (auto* value : node->values) { + auto& users = getUsers(value); + users.erase(node); + } + } + + // Adds a new user to a node. Called when we add or change a value of a node. + void addUser(Node* node, Node* newUser) { users[node].insert(newUser); } + + // Remove all uses of a node. Called when a node is being removed. + void removeAllUsesOf(Node* node) { users.erase(node); } +}; + +} // namespace DataFlow + +} // namespace wasm + +#endif // wasm_dataflow_users diff --git a/binaryen/src/dataflow/utils.h b/binaryen/src/dataflow/utils.h new file mode 100644 --- /dev/null +++ b/binaryen/src/dataflow/utils.h @@ -0,0 +1,154 @@ +/* + * Copyright 2018 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// DataFlow IR is an SSA representation. It can be built from the main +// Binaryen IR. +// +// THe main initial use case was an IR that could easily be converted to +// Souper IR, and the design favors that. +// + +#ifndef wasm_dataflow_utils_h +#define wasm_dataflow_utils_h + +#include "dataflow/node.h" +#include "wasm-printing.h" +#include "wasm.h" + +namespace wasm { + +namespace DataFlow { + +inline std::ostream& dump(Node* node, std::ostream& o, size_t indent = 0) { + auto doIndent = [&]() { + for (size_t i = 0; i < indent; i++) { + o << ' '; + } + }; + doIndent(); + o << '[' << node << ' '; + switch (node->type) { + case Node::Type::Var: + o << "var " << node->wasmType << ' ' << node; + break; + case Node::Type::Expr: { + o << "expr "; + WasmPrinter::printExpression(node->expr, o, true); + break; + } + case Node::Type::Phi: + o << "phi " << node->index; + break; + case Node::Type::Cond: + o << "cond " << node->index; + break; + case Node::Type::Block: { + // don't print the conds - they would recurse + o << "block (" << node->values.size() << " conds)]\n"; + return o; + } + case Node::Type::Zext: + o << "zext"; + break; + case Node::Type::Bad: + o << "bad"; + break; + } + if (!node->values.empty()) { + o << '\n'; + for (auto* value : node->values) { + dump(value, o, indent + 1); + } + doIndent(); + } + o << "] (origin: " << (void*)(node->origin) << ")\n"; + return o; +} + +inline std::ostream& dump(Graph& graph, std::ostream& o) { + for (auto& node : graph.nodes) { + o << "NODE " << node.get() << ": "; + dump(node.get(), o); + if (auto* set = graph.getSet(node.get())) { + o << " and that is set to local " << set->index << '\n'; + } + } + return o; +} + +// Checks if the inputs are all identical - something we could +// probably optimize. Returns false if irrelevant. +inline bool allInputsIdentical(Node* node) { + switch (node->type) { + case Node::Type::Expr: { + if (node->expr->is()) { + return *(node->getValue(0)) == *(node->getValue(1)); + } else if (node->expr->is()) { + return node->getValue(0)->isConst() && node->getValue(1)->isConst() && + node->getValue(2)->isConst(); + } + break; + } + case Node::Type::Phi: { + // Check if any of the others are not equal + for (Index i = 1; i < node->values.size(); i++) { + if (!node->getValue(i)->isConst()) { + return false; + } + } + return true; + } + default: {} + } + return false; +} + +} // namespace DataFlow + +} // namespace wasm + +#endif // wasm_dataflow_utils diff --git a/binaryen/src/emscripten-optimizer/CMakeLists.txt b/binaryen/src/emscripten-optimizer/CMakeLists.txt new file mode 100644 --- /dev/null +++ b/binaryen/src/emscripten-optimizer/CMakeLists.txt @@ -0,0 +1,8 @@ +FILE(GLOB emscripten-optimizer_HEADERS *.h) +set(emscripten-optimizer_SOURCES + optimizer-shared.cpp + parser.cpp + simple_ast.cpp + ${emscripten-optimizer_HEADERS} +) +add_library(emscripten-optimizer OBJECT ${emscripten-optimizer_SOURCES}) diff --git a/binaryen/src/emscripten-optimizer/istring.h b/binaryen/src/emscripten-optimizer/istring.h new file mode 100644 --- /dev/null +++ b/binaryen/src/emscripten-optimizer/istring.h @@ -0,0 +1,218 @@ +/* + * Copyright 2015 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// Interned String type, 100% interned on creation. Comparisons are always just +// a pointer comparison + +#ifndef wasm_istring_h +#define wasm_istring_h + +#include +#include +#include + +#include +#include +#include +#include +#include + +#include "support/threads.h" +#include "support/utilities.h" + +namespace cashew { + +struct IString { + const char* str = nullptr; + + static size_t + hash_c(const char* str) { // see http://www.cse.yorku.ca/~oz/hash.html + unsigned int hash = 5381; + int c; + while ((c = *str++)) { + hash = ((hash << 5) + hash) ^ c; + } + return (size_t)hash; + } + + class CStringHash : public std::hash { + public: + size_t operator()(const char* str) const { return IString::hash_c(str); } + }; + class CStringEqual : public std::equal_to { + public: + bool operator()(const char* x, const char* y) const { + return strcmp(x, y) == 0; + } + }; + + IString() = default; + // if reuse=true, then input is assumed to remain alive; not copied + IString(const char* s, bool reuse = true) { + assert(s); + set(s, reuse); + } + + void set(const char* s, bool reuse = true) { + typedef std::unordered_set + StringSet; + // one global store of strings per thread, we must not access this + // in parallel + thread_local static StringSet strings; + + auto existing = strings.find(s); + + if (existing == strings.end()) { + // if the string isn't already known, we must use a single global + // storage location, guarded by a mutex, so each string is allocated + // exactly once + static std::mutex mutex; + std::unique_lock lock(mutex); + // a single global set contains the actual strings, so we allocate each + // one exactly once. + static StringSet globalStrings; + auto globalExisting = globalStrings.find(s); + if (globalExisting == globalStrings.end()) { + if (!reuse) { + static std::vector> allocated; + allocated.emplace_back(wasm::make_unique(s)); + s = allocated.back()->c_str(); // we'll never modify it, so this is ok + } + // insert into global set + globalStrings.insert(s); + } else { + s = *globalExisting; + } + // add the string to our thread-local set + strings.insert(s); + } else { + s = *existing; + } + + str = s; + } + + void set(const IString& s) { str = s.str; } + + void clear() { str = nullptr; } + + bool operator==(const IString& other) const { + // assert((str == other.str) == !strcmp(str, other.str)); + return str == other.str; // fast! + } + bool operator!=(const IString& other) const { + // assert((str == other.str) == !strcmp(str, other.str)); + return str != other.str; // fast! + } + bool operator<(const IString& other) const { + return strcmp(str ? str : "", other.str ? other.str : "") < 0; + } + + char operator[](int x) const { return str[x]; } + + bool operator!() const { // no string, or empty string + return !str || str[0] == 0; + } + + const char* c_str() const { return str; } + bool equals(const char* other) const { return !strcmp(str, other); } + + bool is() const { return str != nullptr; } + bool isNull() const { return str == nullptr; } + + const char* stripPrefix(const char* prefix) const { + const char* ptr = str; + while (true) { + if (*prefix == 0) { + return ptr; + } + if (*ptr == 0) { + return nullptr; + } + if (*ptr++ != *prefix++) { + return nullptr; + } + } + } + + bool startsWith(const char* prefix) const { + return stripPrefix(prefix) != nullptr; + } + bool startsWith(const IString& prefix) const { + return startsWith(prefix.str); + } + + size_t size() const { return str ? strlen(str) : 0; } +}; + +} // namespace cashew + +// Utilities for creating hashmaps/sets over IStrings + +namespace std { + +template<> struct hash { + size_t operator()(const cashew::IString& str) const { + return std::hash{}(size_t(str.str)); + } +}; + +template<> struct equal_to { + bool operator()(const cashew::IString& x, const cashew::IString& y) const { + return x == y; + } +}; + +} // namespace std + +namespace cashew { + +// IStringSet + +class IStringSet : public std::unordered_set { + std::vector data; + +public: + IStringSet() = default; + IStringSet(const char* init) { // comma-delimited list + int size = strlen(init) + 1; + data.resize(size); + char* curr = &data[0]; + strncpy(curr, init, size); + while (1) { + char* end = strchr(curr, ' '); + if (end) { + *end = 0; + } + insert(curr); + if (!end) { + break; + } + curr = end + 1; + } + } + + bool has(const IString& str) { return count(str) > 0; } +}; + +class IOrderedStringSet : public std::set { +public: + bool has(const IString& str) { return count(str) > 0; } +}; + +} // namespace cashew + +#endif // wasm_istring_h diff --git a/binaryen/src/emscripten-optimizer/optimizer-shared.cpp b/binaryen/src/emscripten-optimizer/optimizer-shared.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/emscripten-optimizer/optimizer-shared.cpp @@ -0,0 +1,357 @@ +/* + * Copyright 2015 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +#include "optimizer.h" +#include "support/safe_integer.h" + +using namespace cashew; + +IString ASM_FLOAT_ZERO; + +IString SIMD_INT8X16_CHECK("SIMD_Int8x16_check"); +IString SIMD_INT16X8_CHECK("SIMD_Int16x8_check"); +IString SIMD_INT32X4_CHECK("SIMD_Int32x4_check"); +IString SIMD_FLOAT32X4_CHECK("SIMD_Float32x4_check"); +IString SIMD_FLOAT64X2_CHECK("SIMD_Float64x2_check"); +IString TEMP_RET0("tempRet0"); + +int parseInt(const char* str) { + int ret = *str - '0'; + while (*(++str)) { + ret *= 10; + ret += *str - '0'; + } + return ret; +} + +HeapInfo parseHeap(const char* name) { + HeapInfo ret; + if (name[0] != 'H' || name[1] != 'E' || name[2] != 'A' || name[3] != 'P') { + ret.valid = false; + return ret; + } + ret.valid = true; + ret.unsign = name[4] == 'U'; + ret.floaty = name[4] == 'F'; + ret.bits = parseInt(name + (ret.unsign || ret.floaty ? 5 : 4)); + ret.type = !ret.floaty ? ASM_INT : (ret.bits == 64 ? ASM_DOUBLE : ASM_FLOAT); + return ret; +} + +AsmType detectType(Ref node, + AsmData* asmData, + bool inVarDef, + IString minifiedFround, + bool allowI64) { + if (node->isString()) { + if (asmData) { + AsmType ret = asmData->getType(node->getCString()); + if (ret != ASM_NONE) { + return ret; + } + } + if (!inVarDef) { + if (node == INF || node == NaN) { + return ASM_DOUBLE; + } + if (node == TEMP_RET0) { + return ASM_INT; + } + return ASM_NONE; + } + // We are in a variable definition, where Math_fround(0) optimized into a + // global constant becomes f0 = Math_fround(0) + if (ASM_FLOAT_ZERO.isNull()) { + ASM_FLOAT_ZERO = node->getIString(); + } else { + assert(node == ASM_FLOAT_ZERO); + } + return ASM_FLOAT; + } + if (node->isNumber()) { + if (!wasm::isInteger(node->getNumber())) { + return ASM_DOUBLE; + } + return ASM_INT; + } + switch (node[0]->getCString()[0]) { + case 'u': { + if (node[0] == UNARY_PREFIX) { + switch (node[1]->getCString()[0]) { + case '+': + return ASM_DOUBLE; + case '-': + return detectType( + node[2], asmData, inVarDef, minifiedFround, allowI64); + case '!': + case '~': + return ASM_INT; + } + break; + } + break; + } + case 'c': { + if (node[0] == CALL) { + if (node[1]->isString()) { + IString name = node[1]->getIString(); + if (name == MATH_FROUND || name == minifiedFround) { + return ASM_FLOAT; + } else if (allowI64 && (name == INT64 || name == INT64_CONST)) { + return ASM_INT64; + } else if (name == SIMD_FLOAT32X4 || name == SIMD_FLOAT32X4_CHECK) { + return ASM_FLOAT32X4; + } else if (name == SIMD_FLOAT64X2 || name == SIMD_FLOAT64X2_CHECK) { + return ASM_FLOAT64X2; + } else if (name == SIMD_INT8X16 || name == SIMD_INT8X16_CHECK) { + return ASM_INT8X16; + } else if (name == SIMD_INT16X8 || name == SIMD_INT16X8_CHECK) { + return ASM_INT16X8; + } else if (name == SIMD_INT32X4 || name == SIMD_INT32X4_CHECK) { + return ASM_INT32X4; + } + } + return ASM_NONE; + } else if (node[0] == CONDITIONAL) { + return detectType(node[2], asmData, inVarDef, minifiedFround, allowI64); + } + break; + } + case 'b': { + if (node[0] == BINARY) { + switch (node[1]->getCString()[0]) { + case '+': + case '-': + case '*': + case '/': + case '%': + return detectType( + node[2], asmData, inVarDef, minifiedFround, allowI64); + case '|': + case '&': + case '^': + case '<': + case '>': // handles <<, >>, >>=, <=, >= + case '=': + case '!': { // handles ==, != + return ASM_INT; + } + } + } + break; + } + case 's': { + if (node[0] == SEQ) { + return detectType(node[2], asmData, inVarDef, minifiedFround, allowI64); + } else if (node[0] == SUB) { + assert(node[1]->isString()); + HeapInfo info = parseHeap(node[1][1]->getCString()); + if (info.valid) { + return ASM_NONE; + } + return info.floaty ? ASM_DOUBLE : ASM_INT; // XXX ASM_FLOAT? + } + break; + } + } + // dump("horrible", node); + // assert(0); + return ASM_NONE; +} + +static void abort_on(Ref node) { + node->stringify(std::cerr); + std::cerr << '\n'; + abort(); +} + +AsmSign detectSign(Ref node, IString minifiedFround) { + if (node->isString()) { + return ASM_FLEXIBLE; + } + if (node->isNumber()) { + double value = node->getNumber(); + if (value < 0) { + return ASM_SIGNED; + } + if (value > uint32_t(-1) || !wasm::isInteger(value)) { + return ASM_NONSIGNED; + } + if (wasm::isSInteger32(value)) { + return ASM_FLEXIBLE; + } + return ASM_UNSIGNED; + } + IString type = node[0]->getIString(); + if (type == BINARY) { + IString op = node[1]->getIString(); + switch (op.str[0]) { + case '>': { + if (op == TRSHIFT) { + return ASM_UNSIGNED; + } + } // fallthrough + case '|': + case '&': + case '^': + case '<': + case '=': + case '!': + return ASM_SIGNED; + case '+': + case '-': + return ASM_FLEXIBLE; + case '*': + case '/': + case '%': + return ASM_NONSIGNED; // without a coercion, these are double + default: + abort_on(node); + } + } else if (type == UNARY_PREFIX) { + IString op = node[1]->getIString(); + switch (op.str[0]) { + case '-': + return ASM_FLEXIBLE; + case '+': + return ASM_NONSIGNED; // XXX double + case '~': + return ASM_SIGNED; + default: + abort_on(node); + } + } else if (type == CONDITIONAL) { + return detectSign(node[2], minifiedFround); + } else if (type == CALL) { + if (node[1]->isString() && + (node[1] == MATH_FROUND || node[1] == minifiedFround)) { + return ASM_NONSIGNED; + } + } else if (type == SEQ) { + return detectSign(node[2], minifiedFround); + } + abort_on(node); + abort(); // avoid warning +} + +Ref makeAsmCoercedZero(AsmType type) { + switch (type) { + case ASM_INT: + return ValueBuilder::makeNum(0); + break; + case ASM_DOUBLE: + return ValueBuilder::makeUnary(PLUS, ValueBuilder::makeNum(0)); + break; + case ASM_FLOAT: { + if (!ASM_FLOAT_ZERO.isNull()) { + return ValueBuilder::makeName(ASM_FLOAT_ZERO); + } else { + return ValueBuilder::makeCall(MATH_FROUND, ValueBuilder::makeNum(0)); + } + break; + } + case ASM_FLOAT32X4: { + return ValueBuilder::makeCall(SIMD_FLOAT32X4, + ValueBuilder::makeNum(0), + ValueBuilder::makeNum(0), + ValueBuilder::makeNum(0), + ValueBuilder::makeNum(0)); + break; + } + case ASM_FLOAT64X2: { + return ValueBuilder::makeCall( + SIMD_FLOAT64X2, ValueBuilder::makeNum(0), ValueBuilder::makeNum(0)); + break; + } + case ASM_INT8X16: { + return ValueBuilder::makeCall(SIMD_INT8X16, + ValueBuilder::makeNum(0), + ValueBuilder::makeNum(0), + ValueBuilder::makeNum(0), + ValueBuilder::makeNum(0), + ValueBuilder::makeNum(0), + ValueBuilder::makeNum(0), + ValueBuilder::makeNum(0), + ValueBuilder::makeNum(0), + ValueBuilder::makeNum(0), + ValueBuilder::makeNum(0), + ValueBuilder::makeNum(0), + ValueBuilder::makeNum(0), + ValueBuilder::makeNum(0), + ValueBuilder::makeNum(0), + ValueBuilder::makeNum(0), + ValueBuilder::makeNum(0)); + break; + } + case ASM_INT16X8: { + return ValueBuilder::makeCall(SIMD_INT16X8, + ValueBuilder::makeNum(0), + ValueBuilder::makeNum(0), + ValueBuilder::makeNum(0), + ValueBuilder::makeNum(0), + ValueBuilder::makeNum(0), + ValueBuilder::makeNum(0), + ValueBuilder::makeNum(0), + ValueBuilder::makeNum(0)); + break; + } + case ASM_INT32X4: { + return ValueBuilder::makeCall(SIMD_INT32X4, + ValueBuilder::makeNum(0), + ValueBuilder::makeNum(0), + ValueBuilder::makeNum(0), + ValueBuilder::makeNum(0)); + break; + } + default: + assert(0); + } + abort(); +} + +Ref makeAsmCoercion(Ref node, AsmType type) { + switch (type) { + case ASM_INT: + return ValueBuilder::makeBinary(node, OR, ValueBuilder::makeNum(0)); + case ASM_DOUBLE: + return ValueBuilder::makeUnary(PLUS, node); + case ASM_FLOAT: + return ValueBuilder::makeCall(MATH_FROUND, node); + case ASM_FLOAT32X4: + return ValueBuilder::makeCall(SIMD_FLOAT32X4_CHECK, node); + case ASM_FLOAT64X2: + return ValueBuilder::makeCall(SIMD_FLOAT64X2_CHECK, node); + case ASM_INT8X16: + return ValueBuilder::makeCall(SIMD_INT8X16_CHECK, node); + case ASM_INT16X8: + return ValueBuilder::makeCall(SIMD_INT16X8_CHECK, node); + case ASM_INT32X4: + return ValueBuilder::makeCall(SIMD_INT32X4_CHECK, node); + case ASM_NONE: + default: + // non-validating code, emit nothing XXX this is dangerous, we should only + // allow this when we know we are not validating + return node; + } +} + +Ref makeSigning(Ref node, AsmSign sign) { + assert(sign == ASM_SIGNED || sign == ASM_UNSIGNED); + return ValueBuilder::makeBinary( + node, sign == ASM_SIGNED ? OR : TRSHIFT, ValueBuilder::makeNum(0)); +} diff --git a/binaryen/src/emscripten-optimizer/optimizer.h b/binaryen/src/emscripten-optimizer/optimizer.h new file mode 100644 --- /dev/null +++ b/binaryen/src/emscripten-optimizer/optimizer.h @@ -0,0 +1,145 @@ +/* + * Copyright 2015 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef wasm_optimizer_h +#define wasm_optimizer_h + +#include "simple_ast.h" + +extern bool preciseF32, receiveJSON, emitJSON, minifyWhitespace, last; + +extern cashew::Ref extraInfo; + +// + +enum AsmType { + ASM_INT = 0, + ASM_DOUBLE, + ASM_FLOAT, + ASM_FLOAT32X4, + ASM_FLOAT64X2, + ASM_INT8X16, + ASM_INT16X8, + ASM_INT32X4, + ASM_INT64, // non-asm.js + ASM_NONE // number of types +}; + +struct AsmData; + +AsmType detectType(cashew::Ref node, + AsmData* asmData = nullptr, + bool inVarDef = false, + cashew::IString minifiedFround = cashew::IString(), + bool allowI64 = false); + +struct AsmData { + struct Local { + Local() = default; + Local(AsmType type, bool param) : type(type), param(param) {} + AsmType type; + bool param; // false if a var + }; + typedef std::unordered_map Locals; + + Locals locals; + std::vector params; // in order + std::vector vars; // in order + AsmType ret; + + cashew::Ref func; + + AsmType getType(const cashew::IString& name) { + auto ret = locals.find(name); + if (ret != locals.end()) { + return ret->second.type; + } + return ASM_NONE; + } + void setType(const cashew::IString& name, AsmType type) { + locals[name].type = type; + } + + bool isLocal(const cashew::IString& name) { return locals.count(name) > 0; } + bool isParam(const cashew::IString& name) { + return isLocal(name) && locals[name].param; + } + bool isVar(const cashew::IString& name) { + return isLocal(name) && !locals[name].param; + } + + // if you want to fill in the data yourself + AsmData() = default; + // if you want to read data from f, and modify it as you go (parallel to + // denormalize) + AsmData(cashew::Ref f); + + void denormalize(); + + void addParam(cashew::IString name, AsmType type) { + locals[name] = Local(type, true); + params.push_back(name); + } + void addVar(cashew::IString name, AsmType type) { + locals[name] = Local(type, false); + vars.push_back(name); + } + + void deleteVar(cashew::IString name) { + locals.erase(name); + for (size_t i = 0; i < vars.size(); i++) { + if (vars[i] == name) { + vars.erase(vars.begin() + i); + break; + } + } + } +}; + +extern cashew::IString ASM_FLOAT_ZERO; + +extern cashew::IString SIMD_INT8X16_CHECK; +extern cashew::IString SIMD_INT16X8_CHECK; +extern cashew::IString SIMD_INT32X4_CHECK; +extern cashew::IString SIMD_FLOAT32X4_CHECK; +extern cashew::IString SIMD_FLOAT64X2_CHECK; + +int parseInt(const char* str); + +struct HeapInfo { + bool valid, unsign, floaty; + int bits; + AsmType type; +}; + +HeapInfo parseHeap(const char* name); + +enum AsmSign { + // small constants can be signed or unsigned, variables are also flexible + ASM_FLEXIBLE = 0, + ASM_SIGNED = 1, + ASM_UNSIGNED = 2, + ASM_NONSIGNED = 3, +}; + +extern AsmSign detectSign(cashew::Ref node, cashew::IString minifiedFround); + +cashew::Ref makeAsmCoercedZero(AsmType type); +cashew::Ref makeAsmCoercion(cashew::Ref node, AsmType type); + +cashew::Ref makeSigning(cashew::Ref node, AsmSign sign); + +#endif // wasm_optimizer_h diff --git a/binaryen/src/emscripten-optimizer/parser.cpp b/binaryen/src/emscripten-optimizer/parser.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/emscripten-optimizer/parser.cpp @@ -0,0 +1,165 @@ +/* + * Copyright 2015 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "parser.h" + +namespace cashew { + +// common strings + +IString TOPLEVEL("toplevel"); +IString DEFUN("defun"); +IString BLOCK("block"); +IString VAR("var"); +IString CONST("const"); +IString CONDITIONAL("conditional"); +IString BINARY("binary"); +IString RETURN("return"); +IString IF("if"); +IString ELSE("else"); +IString WHILE("while"); +IString DO("do"); +IString FOR("for"); +IString SEQ("seq"); +IString SUB("sub"); +IString CALL("call"); +IString LABEL("label"); +IString BREAK("break"); +IString CONTINUE("continue"); +IString SWITCH("switch"); +IString STRING("string"); +IString TRY("try"); +IString INF("inf"); +IString NaN("nan"); +IString LLVM_CTTZ_I32("_llvm_cttz_i32"); +IString UDIVMODDI4("___udivmoddi4"); +IString UNARY_PREFIX("unary-prefix"); +IString UNARY_POSTFIX("unary-postfix"); +IString MATH_FROUND("Math_fround"); +IString MATH_CLZ32("Math_clz32"); +IString INT64("i64"); +IString INT64_CONST("i64_const"); +IString SIMD_FLOAT32X4("SIMD_Float32x4"); +IString SIMD_FLOAT64X2("SIMD_Float64x2"); +IString SIMD_INT8X16("SIMD_Int8x16"); +IString SIMD_INT16X8("SIMD_Int16x8"); +IString SIMD_INT32X4("SIMD_Int32x4"); +IString PLUS("+"); +IString MINUS("-"); +IString OR("|"); +IString AND("&"); +IString XOR("^"); +IString L_NOT("!"); +IString B_NOT("~"); +IString LT("<"); +IString GE(">="); +IString LE("<="); +IString GT(">"); +IString EQ("=="); +IString NE("!="); +IString DIV("/"); +IString MOD("%"); +IString MUL("*"); +IString RSHIFT(">>"); +IString LSHIFT("<<"); +IString TRSHIFT(">>>"); +IString HEAP8("HEAP8"); +IString HEAP16("HEAP16"); +IString HEAP32("HEAP32"); +IString HEAPF32("HEAPF32"); +IString HEAPU8("HEAPU8"); +IString HEAPU16("HEAPU16"); +IString HEAPU32("HEAPU32"); +IString HEAPF64("HEAPF64"); +IString F0("f0"); +IString EMPTY(""); +IString FUNCTION("function"); +IString OPEN_PAREN("("); +IString OPEN_BRACE("["); +IString OPEN_CURLY("{"); +IString CLOSE_CURLY("}"); +IString COMMA(","); +IString QUESTION("?"); +IString COLON(":"); +IString CASE("case"); +IString DEFAULT("default"); +IString DOT("dot"); +IString PERIOD("."); +IString NEW("new"); +IString ARRAY("array"); +IString OBJECT("object"); +IString THROW("throw"); +IString SET("="); +IString ATOMICS("Atomics"); +IString COMPARE_EXCHANGE("compareExchange"); +IString LOAD("load"); +IString STORE("store"); + +IStringSet + keywords("var const function if else do while for break continue return " + "switch case default throw try catch finally true false null new"); + +const char *OPERATOR_INITS = "+-*/%<>&^|~=!,?:.", *SEPARATORS = "([;{}"; + +int MAX_OPERATOR_SIZE = 3; + +std::vector operatorClasses; + +static std::vector> + precedences; // op, type => prec + +struct Init { + Init() { + // operators, rtl, type + operatorClasses.emplace_back(".", false, OperatorClass::Binary); + operatorClasses.emplace_back("! ~ + -", true, OperatorClass::Prefix); + operatorClasses.emplace_back("* / %", false, OperatorClass::Binary); + operatorClasses.emplace_back("+ -", false, OperatorClass::Binary); + operatorClasses.emplace_back("<< >> >>>", false, OperatorClass::Binary); + operatorClasses.emplace_back("< <= > >=", false, OperatorClass::Binary); + operatorClasses.emplace_back("== !=", false, OperatorClass::Binary); + operatorClasses.emplace_back("&", false, OperatorClass::Binary); + operatorClasses.emplace_back("^", false, OperatorClass::Binary); + operatorClasses.emplace_back("|", false, OperatorClass::Binary); + operatorClasses.emplace_back("? :", true, OperatorClass::Tertiary); + operatorClasses.emplace_back("=", true, OperatorClass::Binary); + operatorClasses.emplace_back(",", true, OperatorClass::Binary); + + precedences.resize(OperatorClass::Tertiary + 1); + + for (size_t prec = 0; prec < operatorClasses.size(); prec++) { + for (auto curr : operatorClasses[prec].ops) { + precedences[operatorClasses[prec].type][curr] = prec; + } + } + } +}; + +Init init; + +int OperatorClass::getPrecedence(Type type, IString op) { + return precedences[type][op]; +} + +bool OperatorClass::getRtl(int prec) { return operatorClasses[prec].rtl; } + +bool isIdentInit(char x) { + return (x >= 'a' && x <= 'z') || (x >= 'A' && x <= 'Z') || x == '_' || + x == '$'; +} +bool isIdentPart(char x) { return isIdentInit(x) || (x >= '0' && x <= '9'); } + +} // namespace cashew diff --git a/binaryen/src/emscripten-optimizer/parser.h b/binaryen/src/emscripten-optimizer/parser.h new file mode 100644 --- /dev/null +++ b/binaryen/src/emscripten-optimizer/parser.h @@ -0,0 +1,1136 @@ +/* + * Copyright 2015 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// Pure parsing. Calls methods on a Builder (template argument) to actually +// construct the AST +// +// XXX All parsing methods assume they take ownership of the input string. This +// lets them reuse parts of it. You will segfault if the input string cannot +// be reused and written to. + +#ifndef wasm_parser_h +#define wasm_parser_h + +#include +#include +#include +#include +#include + +#include "istring.h" +#include "support/safe_integer.h" + +namespace cashew { + +// common strings + +extern IString TOPLEVEL; +extern IString DEFUN; +extern IString BLOCK; +extern IString VAR; +extern IString CONST; +extern IString CONDITIONAL; +extern IString BINARY; +extern IString RETURN; +extern IString IF; +extern IString ELSE; +extern IString WHILE; +extern IString DO; +extern IString FOR; +extern IString SEQ; +extern IString SUB; +extern IString CALL; +extern IString LABEL; +extern IString BREAK; +extern IString CONTINUE; +extern IString SWITCH; +extern IString STRING; +extern IString TRY; +extern IString INF; +extern IString NaN; +extern IString LLVM_CTTZ_I32; +extern IString UDIVMODDI4; +extern IString UNARY_PREFIX; +extern IString UNARY_POSTFIX; +extern IString MATH_FROUND; +extern IString MATH_CLZ32; +extern IString INT64; +extern IString INT64_CONST; +extern IString SIMD_FLOAT32X4; +extern IString SIMD_FLOAT64X2; +extern IString SIMD_INT8X16; +extern IString SIMD_INT16X8; +extern IString SIMD_INT32X4; +extern IString PLUS; +extern IString MINUS; +extern IString OR; +extern IString AND; +extern IString XOR; +extern IString L_NOT; +extern IString B_NOT; +extern IString LT; +extern IString GE; +extern IString LE; +extern IString GT; +extern IString EQ; +extern IString NE; +extern IString DIV; +extern IString MOD; +extern IString MUL; +extern IString RSHIFT; +extern IString LSHIFT; +extern IString TRSHIFT; +extern IString HEAP8; +extern IString HEAP16; +extern IString HEAP32; +extern IString HEAPF32; +extern IString HEAPU8; +extern IString HEAPU16; +extern IString HEAPU32; +extern IString HEAPF64; +extern IString F0; +extern IString EMPTY; +extern IString FUNCTION; +extern IString OPEN_PAREN; +extern IString OPEN_BRACE; +extern IString OPEN_CURLY; +extern IString CLOSE_CURLY; +extern IString COMMA; +extern IString QUESTION; +extern IString COLON; +extern IString CASE; +extern IString DEFAULT; +extern IString DOT; +extern IString PERIOD; +extern IString NEW; +extern IString ARRAY; +extern IString OBJECT; +extern IString THROW; +extern IString SET; +extern IString ATOMICS; +extern IString COMPARE_EXCHANGE; +extern IString LOAD; +extern IString STORE; + +extern IStringSet keywords; + +extern const char *OPERATOR_INITS, *SEPARATORS; + +extern int MAX_OPERATOR_SIZE, LOWEST_PREC; + +struct OperatorClass { + enum Type { Binary = 0, Prefix = 1, Postfix = 2, Tertiary = 3 }; + + IStringSet ops; + bool rtl; + Type type; + + OperatorClass(const char* o, bool r, Type t) : ops(o), rtl(r), type(t) {} + + static int getPrecedence(Type type, IString op); + static bool getRtl(int prec); +}; + +extern std::vector operatorClasses; + +extern bool isIdentInit(char x); +extern bool isIdentPart(char x); + +// parser + +template class Parser { + + static bool isSpace(char x) { + return x == 32 || x == 9 || x == 10 || x == 13; + } /* space, tab, linefeed/newline, or return */ + static void skipSpace(char*& curr) { + while (*curr) { + if (isSpace(*curr)) { + curr++; + continue; + } + if (curr[0] == '/' && curr[1] == '/') { + curr += 2; + while (*curr && *curr != '\n') { + curr++; + } + if (*curr) { + curr++; + } + continue; + } + if (curr[0] == '/' && curr[1] == '*') { + curr += 2; + while (*curr && (curr[0] != '*' || curr[1] != '/')) { + curr++; + } + curr += 2; + continue; + } + return; + } + } + + static bool isDigit(char x) { return x >= '0' && x <= '9'; } + + static bool hasChar(const char* list, char x) { + while (*list) { + if (*list++ == x) { + return true; + } + } + return false; + } + + // An atomic fragment of something. Stops at a natural boundary. + enum FragType { + KEYWORD = 0, + OPERATOR = 1, + IDENT = 2, + STRING = 3, // without quotes + INT = 4, + DOUBLE = 5, + SEPARATOR = 6 + }; + + struct Frag { + // MSVC does not allow unrestricted unions: + // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2544.pdf +#ifndef _MSC_VER + union { +#endif + IString str; + double num; +#ifndef _MSC_VER + }; +#endif + int size; + FragType type; + + bool isNumber() const { return type == INT || type == DOUBLE; } + + explicit Frag(char* src) { + char* start = src; + if (isIdentInit(*src)) { + // read an identifier or a keyword + src++; + while (isIdentPart(*src)) { + src++; + } + if (*src == 0) { + str.set(start); + } else { + char temp = *src; + *src = 0; + str.set(start, false); + *src = temp; + } + type = keywords.has(str) ? KEYWORD : IDENT; + } else if (isDigit(*src) || (src[0] == '.' && isDigit(src[1]))) { + if (src[0] == '0' && (src[1] == 'x' || src[1] == 'X')) { + // Explicitly parse hex numbers of form "0x...", because strtod + // supports hex number strings only in C++11, and Visual Studio 2013 + // does not yet support that functionality. + src += 2; + num = 0; + while (1) { + if (*src >= '0' && *src <= '9') { + num *= 16; + num += *src - '0'; + } else if (*src >= 'a' && *src <= 'f') { + num *= 16; + num += *src - 'a' + 10; + } else if (*src >= 'A' && *src <= 'F') { + num *= 16; + num += *src - 'A' + 10; + } else { + break; + } + src++; + } + } else { + num = strtod(start, &src); + } + // asm.js must have a '.' for double values. however, we also tolerate + // uglify's tendency to emit without a '.' (and fix it later with a +). + // for valid asm.js input, the '.' should be enough, and for uglify + // in the emscripten optimizer pipeline, we use simple_ast where + // INT/DOUBLE is quite the same at this point anyhow + type = (std::find(start, src, '.') == src && + (wasm::isSInteger32(num) || wasm::isUInteger32(num))) + ? INT + : DOUBLE; + assert(src > start); + } else if (hasChar(OPERATOR_INITS, *src)) { + switch (*src) { + case '!': + str = src[1] == '=' ? NE : L_NOT; + break; + case '%': + str = MOD; + break; + case '&': + str = AND; + break; + case '*': + str = MUL; + break; + case '+': + str = PLUS; + break; + case ',': + str = COMMA; + break; + case '-': + str = MINUS; + break; + case '.': + str = PERIOD; + break; + case '/': + str = DIV; + break; + case ':': + str = COLON; + break; + case '<': + str = src[1] == '<' ? LSHIFT : (src[1] == '=' ? LE : LT); + break; + case '=': + str = src[1] == '=' ? EQ : SET; + break; + case '>': + str = src[1] == '>' ? (src[2] == '>' ? TRSHIFT : RSHIFT) + : (src[1] == '=' ? GE : GT); + break; + case '?': + str = QUESTION; + break; + case '^': + str = XOR; + break; + case '|': + str = OR; + break; + case '~': + str = B_NOT; + break; + default: + abort(); + } + size = strlen(str.str); +#ifndef NDEBUG + char temp = start[size]; + start[size] = 0; + assert(strcmp(str.str, start) == 0); + start[size] = temp; +#endif + type = OPERATOR; + return; + } else if (hasChar(SEPARATORS, *src)) { + type = SEPARATOR; + char temp = src[1]; + src[1] = 0; + str.set(src, false); + src[1] = temp; + src++; + } else if (*src == '"' || *src == '\'') { + char* end = strchr(src + 1, *src); + *end = 0; + str.set(src + 1); + src = end + 1; + type = STRING; + } else { + dump("frag parsing", src); + abort(); + } + size = src - start; + } + }; + + struct ExpressionElement { + bool isNode; + // MSVC does not allow unrestricted unions: + // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2544.pdf +#ifndef _MSC_VER + union { +#endif + NodeRef node; + IString op; +#ifndef _MSC_VER + }; +#endif + ExpressionElement(NodeRef n) : isNode(true), node(n) {} + ExpressionElement(IString o) : isNode(false), op(o) {} + + NodeRef getNode() { + assert(isNode); + return node; + } + IString getOp() { + assert(!isNode); + return op; + } + }; + + // This is a list of the current stack of node-operator-node-operator-etc. + // this works by each parseExpression call appending to the vector; then + // recursing out, and the toplevel sorts it all + typedef std::vector ExpressionParts; + std::vector expressionPartsStack; + + // Parses an element in a list of such elements, e.g. list of statements in a + // block, or list of parameters in a call + NodeRef parseElement(char*& src, const char* seps = ";") { + // dump("parseElement", src); + skipSpace(src); + Frag frag(src); + src += frag.size; + switch (frag.type) { + case KEYWORD: { + return parseAfterKeyword(frag, src, seps); + } + case IDENT: { + return parseAfterIdent(frag, src, seps); + } + case STRING: + case INT: + case DOUBLE: { + return parseExpression(parseFrag(frag), src, seps); + } + case SEPARATOR: { + if (frag.str == OPEN_PAREN) { + return parseExpression(parseAfterParen(src), src, seps); + } + if (frag.str == OPEN_BRACE) { + return parseExpression(parseAfterBrace(src), src, seps); + } + if (frag.str == OPEN_CURLY) { + return parseExpression(parseAfterCurly(src), src, seps); + } + abort(); + } + case OPERATOR: { + return parseExpression(frag.str, src, seps); + } + default: + /* dump("parseElement", src); printf("bad frag type: %d\n",frag.type); + */ + abort(); + } + return nullptr; + } + + NodeRef parseFrag(Frag& frag) { + switch (frag.type) { + case IDENT: + return Builder::makeName(frag.str); + case STRING: + return Builder::makeString(frag.str); + case INT: + return Builder::makeInt(uint32_t(frag.num)); + case DOUBLE: + return Builder::makeDouble(frag.num); + default: + abort(); + } + return nullptr; + } + + NodeRef parseAfterKeyword(Frag& frag, char*& src, const char* seps) { + skipSpace(src); + if (frag.str == FUNCTION) { + return parseFunction(src, seps); + } else if (frag.str == VAR) { + return parseVar(src, seps, false); + } else if (frag.str == CONST) { + return parseVar(src, seps, true); + } else if (frag.str == RETURN) { + return parseReturn(src, seps); + } else if (frag.str == IF) { + return parseIf(src, seps); + } else if (frag.str == DO) { + return parseDo(src, seps); + } else if (frag.str == WHILE) { + return parseWhile(src, seps); + } else if (frag.str == BREAK) { + return parseBreak(src, seps); + } else if (frag.str == CONTINUE) { + return parseContinue(src, seps); + } else if (frag.str == SWITCH) { + return parseSwitch(src, seps); + } else if (frag.str == NEW) { + return parseNew(src, seps); + } else if (frag.str == FOR) { + return parseFor(src, seps); + } + dump(frag.str.str, src); + abort(); + return nullptr; + } + + NodeRef parseFunction(char*& src, const char* seps) { + Frag name(src); + if (name.type == IDENT) { + src += name.size; + } else { + assert(name.type == SEPARATOR && name.str[0] == '('); + name.str = IString(); + } + NodeRef ret = Builder::makeFunction(name.str); + skipSpace(src); + assert(*src == '('); + src++; + while (1) { + skipSpace(src); + if (*src == ')') { + break; + } + Frag arg(src); + assert(arg.type == IDENT); + src += arg.size; + Builder::appendArgumentToFunction(ret, arg.str); + skipSpace(src); + if (*src == ')') { + break; + } + if (*src == ',') { + src++; + continue; + } + abort(); + } + src++; + Builder::setBlockContent(ret, parseBracketedBlock(src)); + // TODO: parse expression? + return ret; + } + + NodeRef parseVar(char*& src, const char* seps, bool is_const) { + NodeRef ret = Builder::makeVar(is_const); + while (1) { + skipSpace(src); + if (*src == ';') { + break; + } + Frag name(src); + assert(name.type == IDENT); + NodeRef value; + src += name.size; + skipSpace(src); + if (*src == '=') { + src++; + skipSpace(src); + value = parseElement(src, ";,"); + } + Builder::appendToVar(ret, name.str, value); + skipSpace(src); + if (*src == ';') { + break; + } + if (*src == ',') { + src++; + continue; + } + abort(); + } + src++; + return ret; + } + + NodeRef parseReturn(char*& src, const char* seps) { + skipSpace(src); + NodeRef value = !hasChar(seps, *src) ? parseElement(src, seps) : nullptr; + skipSpace(src); + assert(hasChar(seps, *src)); + if (*src == ';') { + src++; + } + return Builder::makeReturn(value); + } + + NodeRef parseIf(char*& src, const char* seps) { + NodeRef condition = parseParenned(src); + NodeRef ifTrue = parseMaybeBracketed(src, seps); + skipSpace(src); + NodeRef ifFalse; + if (!hasChar(seps, *src)) { + Frag next(src); + if (next.type == KEYWORD && next.str == ELSE) { + src += next.size; + ifFalse = parseMaybeBracketed(src, seps); + } + } + return Builder::makeIf(condition, ifTrue, ifFalse); + } + + NodeRef parseDo(char*& src, const char* seps) { + NodeRef body = parseMaybeBracketed(src, seps); + skipSpace(src); + Frag next(src); + assert(next.type == KEYWORD && next.str == WHILE); + src += next.size; + NodeRef condition = parseParenned(src); + return Builder::makeDo(body, condition); + } + + NodeRef parseWhile(char*& src, const char* seps) { + NodeRef condition = parseParenned(src); + NodeRef body = parseMaybeBracketed(src, seps); + return Builder::makeWhile(condition, body); + } + + NodeRef parseFor(char*& src, const char* seps) { + skipSpace(src); + assert(*src == '('); + src++; + NodeRef init = parseElement(src, ";"); + skipSpace(src); + assert(*src == ';'); + src++; + NodeRef condition = parseElement(src, ";"); + skipSpace(src); + assert(*src == ';'); + src++; + NodeRef inc = parseElement(src, ")"); + skipSpace(src); + assert(*src == ')'); + src++; + NodeRef body = parseMaybeBracketed(src, seps); + return Builder::makeFor(init, condition, inc, body); + } + + NodeRef parseBreak(char*& src, const char* seps) { + skipSpace(src); + Frag next(src); + if (next.type == IDENT) { + src += next.size; + } + return Builder::makeBreak(next.type == IDENT ? next.str : IString()); + } + + NodeRef parseContinue(char*& src, const char* seps) { + skipSpace(src); + Frag next(src); + if (next.type == IDENT) { + src += next.size; + } + return Builder::makeContinue(next.type == IDENT ? next.str : IString()); + } + + NodeRef parseSwitch(char*& src, const char* seps) { + NodeRef ret = Builder::makeSwitch(parseParenned(src)); + skipSpace(src); + assert(*src == '{'); + src++; + while (1) { + // find all cases and possibly a default + skipSpace(src); + if (*src == '}') { + break; + } + Frag next(src); + if (next.type == KEYWORD) { + if (next.str == CASE) { + src += next.size; + skipSpace(src); + NodeRef arg; + Frag value(src); + if (value.isNumber()) { + arg = parseFrag(value); + src += value.size; + } else if (value.type == OPERATOR) { + // negative number + assert(value.str == MINUS); + src += value.size; + skipSpace(src); + Frag value2(src); + assert(value2.isNumber()); + arg = Builder::makePrefix(MINUS, parseFrag(value2)); + src += value2.size; + } else { + // identifier and function call + assert(value.type == IDENT); + src += value.size; + skipSpace(src); + arg = parseCall(parseFrag(value), src); + } + Builder::appendCaseToSwitch(ret, arg); + skipSpace(src); + assert(*src == ':'); + src++; + continue; + } else if (next.str == DEFAULT) { + src += next.size; + Builder::appendDefaultToSwitch(ret); + skipSpace(src); + assert(*src == ':'); + src++; + continue; + } + // otherwise, may be some keyword that happens to start a block (e.g. + // case 1: _return_ 5) + } + // not case X: or default: or }, so must be some code + skipSpace(src); + bool explicitBlock = *src == '{'; + NodeRef subBlock = explicitBlock ? parseBracketedBlock(src) + : parseBlock(src, ";}", CASE, DEFAULT); + Builder::appendCodeToSwitch(ret, subBlock, explicitBlock); + } + skipSpace(src); + assert(*src == '}'); + src++; + return ret; + } + + NodeRef parseNew(char*& src, const char* seps) { + return Builder::makeNew(parseElement(src, seps)); + } + + NodeRef parseAfterIdent(Frag& frag, char*& src, const char* seps) { + skipSpace(src); + if (*src == '(') { + return parseExpression(parseCall(parseFrag(frag), src), src, seps); + } + if (*src == '[') { + return parseExpression(parseIndexing(parseFrag(frag), src), src, seps); + } + if (*src == ':' && expressionPartsStack.back().size() == 0) { + src++; + skipSpace(src); + NodeRef inner; + if (*src == '{') { + // context lets us know this is not an object, but a block + inner = parseBracketedBlock(src); + } else { + inner = parseElement(src, seps); + } + return Builder::makeLabel(frag.str, inner); + } + if (*src == '.') { + return parseExpression(parseDotting(parseFrag(frag), src), src, seps); + } + return parseExpression(parseFrag(frag), src, seps); + } + + NodeRef parseCall(NodeRef target, char*& src) { + expressionPartsStack.resize(expressionPartsStack.size() + 1); + assert(*src == '('); + src++; + NodeRef ret = Builder::makeCall(target); + while (1) { + skipSpace(src); + if (*src == ')') { + break; + } + Builder::appendToCall(ret, parseElement(src, ",)")); + skipSpace(src); + if (*src == ')') { + break; + } + if (*src == ',') { + src++; + continue; + } + abort(); + } + src++; + assert(expressionPartsStack.back().size() == 0); + expressionPartsStack.pop_back(); + return ret; + } + + NodeRef parseIndexing(NodeRef target, char*& src) { + expressionPartsStack.resize(expressionPartsStack.size() + 1); + assert(*src == '['); + src++; + NodeRef ret = Builder::makeIndexing(target, parseElement(src, "]")); + skipSpace(src); + assert(*src == ']'); + src++; + assert(expressionPartsStack.back().size() == 0); + expressionPartsStack.pop_back(); + return ret; + } + + NodeRef parseDotting(NodeRef target, char*& src) { + assert(*src == '.'); + src++; + Frag key(src); + assert(key.type == IDENT); + src += key.size; + return Builder::makeDot(target, key.str); + } + + NodeRef parseAfterParen(char*& src) { + expressionPartsStack.resize(expressionPartsStack.size() + 1); + skipSpace(src); + NodeRef ret = parseElement(src, ")"); + skipSpace(src); + assert(*src == ')'); + src++; + assert(expressionPartsStack.back().size() == 0); + expressionPartsStack.pop_back(); + return ret; + } + + NodeRef parseAfterBrace(char*& src) { + expressionPartsStack.resize(expressionPartsStack.size() + 1); + NodeRef ret = Builder::makeArray(); + while (1) { + skipSpace(src); + assert(*src); + if (*src == ']') { + break; + } + NodeRef element = parseElement(src, ",]"); + Builder::appendToArray(ret, element); + skipSpace(src); + if (*src == ']') { + break; + } + if (*src == ',') { + src++; + continue; + } + abort(); + } + src++; + return ret; + } + + NodeRef parseAfterCurly(char*& src) { + expressionPartsStack.resize(expressionPartsStack.size() + 1); + NodeRef ret = Builder::makeObject(); + while (1) { + skipSpace(src); + assert(*src); + if (*src == '}') { + break; + } + Frag key(src); + assert(key.type == IDENT || key.type == STRING); + src += key.size; + skipSpace(src); + assert(*src == ':'); + src++; + NodeRef value = parseElement(src, ",}"); + Builder::appendToObject(ret, key.str, value); + skipSpace(src); + if (*src == '}') { + break; + } + if (*src == ',') { + src++; + continue; + } + abort(); + } + src++; + return ret; + } + + void dumpParts(ExpressionParts& parts, int i) { + printf("expressionparts: %d (at %d)\n", parts.size(), i); + printf("| "); + for (int i = 0; i < parts.size(); i++) { + if (parts[i].isNode) { + parts[i].getNode()->stringify(std::cout); + printf(" "); + } else { + printf(" _%s_ ", parts[i].getOp().str); + } + } + printf("|\n"); + } + + NodeRef makeBinary(NodeRef left, IString op, NodeRef right) { + if (op == PERIOD) { + return Builder::makeDot(left, right); + } else { + return Builder::makeBinary(left, op, right); + } + } + + NodeRef + parseExpression(ExpressionElement initial, char*& src, const char* seps) { + // dump("parseExpression", src); + ExpressionParts& parts = expressionPartsStack.back(); + skipSpace(src); + if (*src == 0 || hasChar(seps, *src)) { + if (parts.size() > 0) { + parts.push_back(initial); // cherry on top of the cake + } + return initial.getNode(); + } + bool top = parts.size() == 0; + if (initial.isNode) { + Frag next(src); + if (next.type == OPERATOR) { + parts.push_back(initial); + src += next.size; + parts.push_back(next.str); + } else { + if (*src == '(') { + initial = parseCall(initial.getNode(), src); + } else if (*src == '[') { + initial = parseIndexing(initial.getNode(), src); + } else { + dump("bad parseExpression state", src); + abort(); + } + return parseExpression(initial, src, seps); + } + } else { + parts.push_back(initial); + } + NodeRef last = parseElement(src, seps); + if (!top) { + return last; + } + { + // |parts| may have been invalidated by that call + ExpressionParts& parts = expressionPartsStack.back(); + // we are the toplevel. sort it all out + // collapse right to left, highest priority first + // dumpParts(parts, 0); + for (auto& ops : operatorClasses) { + if (ops.rtl) { + // right to left + for (int i = parts.size() - 1; i >= 0; i--) { + if (parts[i].isNode) { + continue; + } + IString op = parts[i].getOp(); + if (!ops.ops.has(op)) { + continue; + } + if (ops.type == OperatorClass::Binary && i > 0 && + i < (int)parts.size() - 1) { + parts[i] = + makeBinary(parts[i - 1].getNode(), op, parts[i + 1].getNode()); + parts.erase(parts.begin() + i + 1); + parts.erase(parts.begin() + i - 1); + } else if (ops.type == OperatorClass::Prefix && + i < (int)parts.size() - 1) { + if (i > 0 && parts[i - 1].isNode) { + // cannot apply prefix operator if it would join two nodes + continue; + } + parts[i] = Builder::makePrefix(op, parts[i + 1].getNode()); + parts.erase(parts.begin() + i + 1); + } else if (ops.type == OperatorClass::Tertiary) { + // we must be at X ? Y : Z + // ^ + // dumpParts(parts, i); + if (op != COLON) { + continue; + } + assert(i < (int)parts.size() - 1 && i >= 3); + if (parts[i - 2].getOp() != QUESTION) { + continue; // e.g. x ? y ? 1 : 0 : 2 + } + parts[i - 3] = Builder::makeConditional(parts[i - 3].getNode(), + parts[i - 1].getNode(), + parts[i + 1].getNode()); + parts.erase(parts.begin() + i - 2, parts.begin() + i + 2); + // basically a reset, due to things like x ? y ? 1 : 0 : 2 + i = parts.size(); + } // TODO: postfix + } + } else { + // left to right + for (int i = 0; i < (int)parts.size(); i++) { + if (parts[i].isNode) { + continue; + } + IString op = parts[i].getOp(); + if (!ops.ops.has(op)) { + continue; + } + if (ops.type == OperatorClass::Binary && i > 0 && + i < (int)parts.size() - 1) { + parts[i] = + makeBinary(parts[i - 1].getNode(), op, parts[i + 1].getNode()); + parts.erase(parts.begin() + i + 1); + parts.erase(parts.begin() + i - 1); + i--; + } else if (ops.type == OperatorClass::Prefix && + i < (int)parts.size() - 1) { + if (i > 0 && parts[i - 1].isNode) { + // cannot apply prefix operator if it would join two nodes + continue; + } + parts[i] = Builder::makePrefix(op, parts[i + 1].getNode()); + parts.erase(parts.begin() + i + 1); + // allow a previous prefix operator to cascade + i = std::max(i - 2, 0); + } // TODO: tertiary, postfix + } + } + } + assert(parts.size() == 1); + NodeRef ret = parts[0].getNode(); + parts.clear(); + return ret; + } + } + + // Parses a block of code (e.g. a bunch of statements inside {,}, or the top + // level of o file) + NodeRef parseBlock(char*& src, + const char* seps = ";", + IString keywordSep1 = IString(), + IString keywordSep2 = IString()) { + NodeRef block = Builder::makeBlock(); + // dump("parseBlock", src); + while (1) { + skipSpace(src); + if (*src == 0) { + break; + } + if (*src == ';') { + src++; // skip a statement in this block + continue; + } + if (hasChar(seps, *src)) { + break; + } + if (!!keywordSep1) { + Frag next(src); + if (next.type == KEYWORD && next.str == keywordSep1) { + break; + } + } + if (!!keywordSep2) { + Frag next(src); + if (next.type == KEYWORD && next.str == keywordSep2) { + break; + } + } + NodeRef element = parseElementOrStatement(src, seps); + Builder::appendToBlock(block, element); + } + return block; + } + + NodeRef parseBracketedBlock(char*& src) { + skipSpace(src); + assert(*src == '{'); + src++; + // the two are not symmetrical, ; is just internally separating, } is the + // final one - parseBlock knows all this + NodeRef block = parseBlock(src, ";}"); + assert(*src == '}'); + src++; + return block; + } + + NodeRef parseElementOrStatement(char*& src, const char* seps) { + skipSpace(src); + if (*src == ';') { + src++; + // we don't need the brackets here, but oh well + return Builder::makeBlock(); + } + if (*src == '{') { // detect a trivial {} in a statement context + char* before = src; + src++; + skipSpace(src); + if (*src == '}') { + src++; + // we don't need the brackets here, but oh well + return Builder::makeBlock(); + } + src = before; + } + NodeRef ret = parseElement(src, seps); + skipSpace(src); + if (*src == ';') { + ret = Builder::makeStatement(ret); + src++; + } + return ret; + } + + NodeRef parseMaybeBracketed(char*& src, const char* seps) { + skipSpace(src); + return *src == '{' ? parseBracketedBlock(src) + : parseElementOrStatement(src, seps); + } + + NodeRef parseParenned(char*& src) { + skipSpace(src); + assert(*src == '('); + src++; + NodeRef ret = parseElement(src, ")"); + skipSpace(src); + assert(*src == ')'); + src++; + return ret; + } + + // Debugging + + char* allSource = nullptr; + int allSize = 0; + + static void dump(const char* where, char* curr) { + /* + printf("%s:\n=============\n", where); + for (int i = 0; i < allSize; i++) + printf("%c", allSource[i] ? allSource[i] : + '?'); + printf("\n"); + for (int i = 0; i < (curr - allSource); i++) printf(" "); + printf("^\n=============\n"); + */ + fprintf(stderr, "%s:\n==========\n", where); + int newlinesLeft = 2; + int charsLeft = 200; + while (*curr) { + if (*curr == '\n') { + newlinesLeft--; + if (newlinesLeft == 0) { + break; + } + } + charsLeft--; + if (charsLeft == 0) { + break; + } + fprintf(stderr, "%c", *curr++); + } + fprintf(stderr, "\n\n"); + } + +public: + Parser() { expressionPartsStack.resize(1); } + + // Highest-level parsing, as of a JavaScript script file. + NodeRef parseToplevel(char* src) { + allSource = src; + allSize = strlen(src); + NodeRef toplevel = Builder::makeToplevel(); + Builder::setBlockContent(toplevel, parseBlock(src)); + return toplevel; + } +}; + +} // namespace cashew + +#endif // wasm_parser_h diff --git a/binaryen/src/emscripten-optimizer/simple_ast.cpp b/binaryen/src/emscripten-optimizer/simple_ast.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/emscripten-optimizer/simple_ast.cpp @@ -0,0 +1,191 @@ +/* + * Copyright 2015 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "simple_ast.h" + +namespace cashew { + +// Ref methods + +Ref& Ref::operator[](unsigned x) { return (*get())[x]; } + +Ref& Ref::operator[](IString x) { return (*get())[x]; } + +bool Ref::operator==(const char* str) { + return get()->isString() && !strcmp(get()->str.str, str); +} + +bool Ref::operator!=(const char* str) { + return get()->isString() ? !!strcmp(get()->str.str, str) : true; +} + +bool Ref::operator==(const IString& str) { + return get()->isString() && get()->str == str; +} + +bool Ref::operator!=(const IString& str) { + return get()->isString() && get()->str != str; +} + +bool Ref::operator==(Ref other) { return **this == *other; } + +bool Ref::operator!() { return !get() || get()->isNull(); } + +// Arena + +GlobalMixedArena arena; + +// Value + +Value& Value::setAssign(Ref target, Ref value) { + asAssign()->target() = target; + asAssign()->value() = value; + return *this; +} + +Value& Value::setAssignName(IString target, Ref value) { + asAssignName()->target() = target; + asAssignName()->value() = value; + return *this; +} + +Assign* Value::asAssign() { + assert(isAssign()); + return static_cast(this); +} + +AssignName* Value::asAssignName() { + assert(isAssignName()); + return static_cast(this); +} + +void Value::stringify(std::ostream& os, bool pretty) { + static int indent = 0; +#define indentify() \ + { \ + for (int i_ = 0; i_ < indent; i_++) \ + os << " "; \ + } + switch (type) { + case String: { + if (str.str) { + os << '"' << str.str << '"'; + } else { + os << "\"(null)\""; + } + break; + } + case Number: { + // doubles can have 17 digits of precision + os << std::setprecision(17) << num; + break; + } + case Array: { + if (arr->size() == 0) { + os << "[]"; + break; + } + os << '['; + if (pretty) { + os << std::endl; + indent++; + } + for (size_t i = 0; i < arr->size(); i++) { + if (i > 0) { + if (pretty) { + os << "," << std::endl; + } else { + os << ", "; + } + } + indentify(); + (*arr)[i]->stringify(os, pretty); + } + if (pretty) { + os << std::endl; + indent--; + } + indentify(); + os << ']'; + break; + } + case Null: { + os << "null"; + break; + } + case Bool: { + os << (boo ? "true" : "false"); + break; + } + case Object: { + os << '{'; + if (pretty) { + os << std::endl; + indent++; + } + bool first = true; + for (auto i : *obj) { + if (first) { + first = false; + } else { + os << ", "; + if (pretty) { + os << std::endl; + } + } + indentify(); + os << '"' << i.first.c_str() << "\": "; + i.second->stringify(os, pretty); + } + if (pretty) { + os << std::endl; + indent--; + } + indentify(); + os << '}'; + break; + } + case Assign_: { + os << "["; + ref->stringify(os, pretty); + os << ", "; + asAssign()->value()->stringify(os, pretty); + os << "]"; + break; + } + case AssignName_: { + os << "[\"" << asAssignName()->target().str << "\""; + os << ", "; + asAssignName()->value()->stringify(os, pretty); + os << "]"; + break; + } + } +} + +// dump + +void dump(const char* str, Ref node, bool pretty) { + std::cerr << str << ": "; + if (!!node) { + node->stringify(std::cerr, pretty); + } else { + std::cerr << "(nullptr)"; + } + std::cerr << std::endl; +} + +} // namespace cashew diff --git a/binaryen/src/emscripten-optimizer/simple_ast.h b/binaryen/src/emscripten-optimizer/simple_ast.h new file mode 100644 --- /dev/null +++ b/binaryen/src/emscripten-optimizer/simple_ast.h @@ -0,0 +1,1851 @@ +/* + * Copyright 2015 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef wasm_simple_ast_h +#define wasm_simple_ast_h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "mixed_arena.h" +#include "parser.h" +#include "snprintf.h" +#include "support/safe_integer.h" + +#define err(str) fprintf(stderr, str "\n"); +#define errv(str, ...) fprintf(stderr, str "\n", __VA_ARGS__); +#define printErr err + +namespace cashew { + +struct Value; +struct Ref; + +void dump(const char* str, Ref node, bool pretty = false); + +// Reference to a value, plus some operators for convenience +struct Ref { + Value* inst; + + Ref(Value* v = nullptr) : inst(v) {} + + Value* get() { return inst; } + + Value& operator*() { return *inst; } + Value* operator->() { return inst; } + Ref& operator[](unsigned x); + Ref& operator[](IString x); + + // special conveniences + bool operator==(const char* str); // comparison to string, which is by value + bool operator!=(const char* str); + bool operator==(const IString& str); + bool operator!=(const IString& str); + // prevent Ref == number, which is potentially ambiguous; use ->getNumber() == + // number + bool operator==(double d) { + abort(); + return false; + } + bool operator==(Ref other); + bool operator!(); // check if null, in effect +}; + +// Arena allocation, free it all on process exit + +// A mixed arena for global allocation only, so members do not +// receive an allocator, they all use the global one anyhow +class GlobalMixedArena : public MixedArena { +public: + template T* alloc() { + auto* ret = static_cast(allocSpace(sizeof(T), alignof(T))); + new (ret) T(); + return ret; + } +}; + +extern GlobalMixedArena arena; + +class ArrayStorage : public ArenaVectorBase { +public: + void allocate(size_t size) { + allocatedElements = size; + data = static_cast( + arena.allocSpace(sizeof(Ref) * allocatedElements, alignof(Ref))); + } +}; + +struct Assign; +struct AssignName; + +// Main value type +struct Value { + enum Type { + String = 0, + Number = 1, + Array = 2, + Null = 3, + Bool = 4, + Object = 5, + Assign_ = 6, // ref = target + AssignName_ = 7 + }; + + Type type = Null; + + typedef std::unordered_map ObjectStorage; + + // MSVC does not allow unrestricted unions: + // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2544.pdf +#ifdef _MSC_VER + IString str; +#endif + union { // TODO: optimize +#ifndef _MSC_VER + IString str; +#endif + double num; + ArrayStorage* arr; + bool boo; + ObjectStorage* obj; + Ref ref; + }; + + // constructors all copy their input + Value() {} + explicit Value(const char* s) { setString(s); } + explicit Value(double n) { setNumber(n); } + explicit Value(ArrayStorage& a) { + setArray(); + *arr = a; + } + // no bool constructor - would endanger the double one (int might convert the + // wrong way) + + ~Value() { free(); } + + void free() { + if (type == Array) { + arr->clear(); + } else if (type == Object) { + delete obj; + } + type = Null; + num = 0; + } + + Value& setString(const char* s) { + free(); + type = String; + str.set(s); + return *this; + } + Value& setString(const IString& s) { + free(); + type = String; + str.set(s); + return *this; + } + Value& setNumber(double n) { + free(); + type = Number; + num = n; + return *this; + } + Value& setArray(ArrayStorage& a) { + free(); + type = Array; + arr = arena.alloc(); + *arr = a; + return *this; + } + Value& setArray(size_t size_hint = 0) { + free(); + type = Array; + arr = arena.alloc(); + arr->reserve(size_hint); + return *this; + } + Value& setNull() { + free(); + type = Null; + return *this; + } + // Bool in the name, as otherwise might overload over int + Value& setBool(bool b) { + free(); + type = Bool; + boo = b; + return *this; + } + Value& setObject() { + free(); + type = Object; + obj = new ObjectStorage(); + return *this; + } + Value& setAssign(Ref target, Ref value); + Value& setAssignName(IString target, Ref value); + + bool isString() { return type == String; } + bool isNumber() { return type == Number; } + bool isArray() { return type == Array; } + bool isNull() { return type == Null; } + bool isBool() { return type == Bool; } + bool isObject() { return type == Object; } + bool isAssign() { return type == Assign_; } + bool isAssignName() { return type == AssignName_; } + + // avoid overloading == as it might overload over int + bool isBool(bool b) { return type == Bool && b == boo; } + + // convenience function to check if something is an array and + // also has a certain string as the first element. This is a + // very common operation as the first element defines the node + // type for most ast nodes + bool isArray(IString name) { return isArray() && (*this)[0] == name; } + + const char* getCString() { + assert(isString()); + return str.str; + } + IString& getIString() { + assert(isString()); + return str; + } + double& getNumber() { + assert(isNumber()); + return num; + } + ArrayStorage& getArray() { + assert(isArray()); + return *arr; + } + bool& getBool() { + assert(isBool()); + return boo; + } + + Assign* asAssign(); + AssignName* asAssignName(); + + int32_t getInteger() { // convenience function to get a known integer + assert(wasm::isInteger(getNumber())); + int32_t ret = getNumber(); + assert(double(ret) == getNumber()); // no loss in conversion + return ret; + } + + Value& operator=(const Value& other) { + free(); + switch (other.type) { + case String: + setString(other.str); + break; + case Number: + setNumber(other.num); + break; + case Array: + setArray(*other.arr); + break; + case Null: + setNull(); + break; + case Bool: + setBool(other.boo); + break; + default: + abort(); // TODO + } + return *this; + } + + bool operator==(const Value& other) { + if (type != other.type) { + return false; + } + switch (other.type) { + case String: + return str == other.str; + case Number: + return num == other.num; + case Array: + return this == &other; // if you want a deep compare, use deepCompare + case Null: + break; + case Bool: + return boo == other.boo; + case Object: + return this == &other; // if you want a deep compare, use deepCompare + default: + abort(); + } + return true; + } + + char* parse(char* curr) { + /* space, tab, linefeed/newline, or return */ +#define is_json_space(x) (x == 32 || x == 9 || x == 10 || x == 13) +#define skip() \ + { \ + while (*curr && is_json_space(*curr)) \ + curr++; \ + } + skip(); + if (*curr == '"') { + // String + curr++; + char* close = strchr(curr, '"'); + assert(close); + *close = 0; // end this string, and reuse it straight from the input + setString(curr); + curr = close + 1; + } else if (*curr == '[') { + // Array + curr++; + skip(); + setArray(); + while (*curr != ']') { + Ref temp = arena.alloc(); + arr->push_back(temp); + curr = temp->parse(curr); + skip(); + if (*curr == ']') { + break; + } + assert(*curr == ','); + curr++; + skip(); + } + curr++; + } else if (*curr == 'n') { + // Null + assert(strncmp(curr, "null", 4) == 0); + setNull(); + curr += 4; + } else if (*curr == 't') { + // Bool true + assert(strncmp(curr, "true", 4) == 0); + setBool(true); + curr += 4; + } else if (*curr == 'f') { + // Bool false + assert(strncmp(curr, "false", 5) == 0); + setBool(false); + curr += 5; + } else if (*curr == '{') { + // Object + curr++; + skip(); + setObject(); + while (*curr != '}') { + assert(*curr == '"'); + curr++; + char* close = strchr(curr, '"'); + assert(close); + *close = 0; // end this string, and reuse it straight from the input + IString key(curr); + curr = close + 1; + skip(); + assert(*curr == ':'); + curr++; + skip(); + Ref value = arena.alloc(); + curr = value->parse(curr); + (*obj)[key] = value; + skip(); + if (*curr == '}') { + break; + } + assert(*curr == ','); + curr++; + skip(); + } + curr++; + } else { + // Number + char* after; + setNumber(strtod(curr, &after)); + curr = after; + } + return curr; + } + + void stringify(std::ostream& os, bool pretty = false); + + // String operations + + // Number operations + + // Array operations + + size_t size() { + assert(isArray()); + return arr->size(); + } + + bool empty() { return size() == 0; } + + void setSize(size_t size) { + assert(isArray()); + auto old = arr->size(); + if (old != size) { + arr->resize(size); + } + if (old < size) { + for (auto i = old; i < size; i++) { + (*arr)[i] = arena.alloc(); + } + } + } + + Ref& operator[](unsigned x) { + assert(isArray()); + return (*arr)[x]; + } + + Value& push_back(Ref r) { + assert(isArray()); + arr->push_back(r); + return *this; + } + Ref pop_back() { + assert(isArray()); + Ref ret = arr->back(); + arr->pop_back(); + return ret; + } + + Ref back() { + assert(isArray()); + if (arr->size() == 0) { + return nullptr; + } + return arr->back(); + } + + void splice(int x, int num) { + assert(isArray()); + arr->erase(arr->begin() + x, arr->begin() + x + num); + } + + int indexOf(Ref other) { + assert(isArray()); + for (size_t i = 0; i < arr->size(); i++) { + if (other == (*arr)[i]) { + return i; + } + } + return -1; + } + + Ref map(std::function func) { + assert(isArray()); + Ref ret = arena.alloc(); + ret->setArray(); + for (size_t i = 0; i < arr->size(); i++) { + ret->push_back(func((*arr)[i])); + } + return ret; + } + + Ref filter(std::function func) { + assert(isArray()); + Ref ret = arena.alloc(); + ret->setArray(); + for (size_t i = 0; i < arr->size(); i++) { + Ref curr = (*arr)[i]; + if (func(curr)) { + ret->push_back(curr); + } + } + return ret; + } + + /* + void forEach(std::function func) { + for (size_t i = 0; i < arr->size(); i++) { + func((*arr)[i]); + } + } + */ + + // Null operations + + // Bool operations + + // Object operations + + Ref& operator[](IString x) { + assert(isObject()); + return (*obj)[x]; + } + + bool has(IString x) { + assert(isObject()); + return obj->count(x) > 0; + } +}; + +struct Assign : public Value { + Ref value_; + + Assign(Ref targetInit, Ref valueInit) { + type = Assign_; + target() = targetInit; + value() = valueInit; + } + + Assign() : Assign(nullptr, nullptr) {} + + Ref& target() { return ref; } + Ref& value() { return value_; } +}; + +struct AssignName : public Value { + IString target_; + + AssignName(IString targetInit, Ref valueInit) { + type = AssignName_; + target() = targetInit; + value() = valueInit; + } + + AssignName() : AssignName(IString(), nullptr) {} + + IString& target() { return target_; } + Ref& value() { return ref; } +}; + +// JS printing support + +struct JSPrinter { + bool pretty, finalize; + + char* buffer = nullptr; + size_t size = 0; + size_t used = 0; + + int indent = 0; + bool possibleSpace = false; // add a space to separate identifiers + + Ref ast; + + JSPrinter(bool pretty_, bool finalize_, Ref ast_) + : pretty(pretty_), finalize(finalize_), ast(ast_) {} + + ~JSPrinter() { free(buffer); } + + void printAst() { + print(ast); + ensure(1); + buffer[used] = 0; + } + + // Utils + + void ensure(int safety = 100) { + if (size >= used + safety) { + return; + } + size = std::max((size_t)1024, size * 2) + safety; + if (!buffer) { + buffer = (char*)malloc(size); + if (!buffer) { + errv("Out of memory allocating %zd bytes for output buffer!", size); + abort(); + } + } else { + char* buf = (char*)realloc(buffer, size); + if (!buf) { + free(buffer); + errv("Out of memory allocating %zd bytes for output buffer!", size); + abort(); + } + buffer = buf; + } + } + + void emit(char c) { + maybeSpace(c); + if (!pretty && c == '}' && buffer[used - 1] == ';') { + used--; // optimize ;} into }, the ; is not separating anything + } + ensure(1); + buffer[used++] = c; + } + + void emit(const char* s) { + maybeSpace(*s); + int len = strlen(s); + ensure(len + 1); + strncpy(buffer + used, s, len + 1); + used += len; + } + + void newline() { + if (!pretty) { + return; + } + emit('\n'); + for (int i = 0; i < indent; i++) { + emit(' '); + } + } + + void space() { + if (pretty) { + emit(' '); + } + } + + void safeSpace() { + if (pretty) { + emit(' '); + } else { + possibleSpace = true; + } + } + + void maybeSpace(char s) { + if (possibleSpace) { + possibleSpace = false; + if (isIdentPart(s)) { + emit(' '); + } + } + } + + bool isNothing(Ref node) { + return node->isArray() && node[0] == TOPLEVEL && node[1]->size() == 0; + } + + bool isDefun(Ref node) { return node->isArray() && node[0] == DEFUN; } + + bool endsInBlock(Ref node) { + if (node->isArray() && node[0] == BLOCK) { + return true; + } + // Check for a label on a block + if (node->isArray() && node[0] == LABEL && endsInBlock(node[2])) { + return true; + } + // Check for an if + if (node->isArray() && node[0] == IF && + endsInBlock(ifHasElse(node) ? node[3] : node[2])) { + return true; + } + return false; + } + + bool isIf(Ref node) { return node->isArray() && node[0] == IF; } + + void print(Ref node) { + ensure(); + if (node->isString()) { + printName(node); + return; + } + if (node->isNumber()) { + printNum(node); + return; + } + if (node->isAssignName()) { + printAssignName(node); + return; + } + if (node->isAssign()) { + printAssign(node); + return; + } + IString type = node[0]->getIString(); + switch (type.str[0]) { + case 'a': { + if (type == ARRAY) { + printArray(node); + } else { + abort(); + } + break; + } + case 'b': { + if (type == BINARY) { + printBinary(node); + } else if (type == BLOCK) { + printBlock(node); + } else if (type == BREAK) { + printBreak(node); + } else { + abort(); + } + break; + } + case 'c': { + if (type == CALL) { + printCall(node); + } else if (type == CONDITIONAL) { + printConditional(node); + } else if (type == CONTINUE) { + printContinue(node); + } else { + abort(); + } + break; + } + case 'd': { + if (type == DEFUN) { + printDefun(node); + } else if (type == DO) { + printDo(node); + } else if (type == DOT) { + printDot(node); + } else { + abort(); + } + break; + } + case 'i': { + if (type == IF) { + printIf(node); + } else { + abort(); + } + break; + } + case 'l': { + if (type == LABEL) { + printLabel(node); + } else { + abort(); + } + break; + } + case 'n': { + if (type == NEW) { + printNew(node); + } else { + abort(); + } + break; + } + case 'o': { + if (type == OBJECT) { + printObject(node); + } + break; + } + case 'r': { + if (type == RETURN) { + printReturn(node); + } else { + abort(); + } + break; + } + case 's': { + if (type == SUB) { + printSub(node); + } else if (type == SEQ) { + printSeq(node); + } else if (type == SWITCH) { + printSwitch(node); + } else if (type == STRING) { + printString(node); + } else { + abort(); + } + break; + } + case 't': { + if (type == TOPLEVEL) { + printToplevel(node); + } else if (type == TRY) { + printTry(node); + } else { + abort(); + } + break; + } + case 'u': { + if (type == UNARY_PREFIX) { + printUnaryPrefix(node); + } else { + abort(); + } + break; + } + case 'v': { + if (type == VAR) { + printVar(node); + } else { + abort(); + } + break; + } + case 'w': { + if (type == WHILE) { + printWhile(node); + } else { + abort(); + } + break; + } + default: { + errv("cannot yet print %s\n", type.str); + abort(); + } + } + } + + // print a node, and if nothing is emitted, emit something instead + void print(Ref node, const char* otherwise) { + auto last = used; + print(node); + if (used == last) { + emit(otherwise); + } + } + + void printStats(Ref stats) { + bool first = true; + for (size_t i = 0; i < stats->size(); i++) { + Ref curr = stats[i]; + if (!isNothing(curr)) { + if (first) { + first = false; + } else { + newline(); + } + print(curr); + if (!isDefun(curr) && !endsInBlock(curr) && !isIf(curr)) { + emit(';'); + } + } + } + } + + void printToplevel(Ref node) { + if (node[1]->size() > 0) { + printStats(node[1]); + } + } + + void printBlock(Ref node) { + if (node->size() == 1 || node[1]->size() == 0) { + emit("{}"); + return; + } + emit('{'); + indent++; + newline(); + printStats(node[1]); + indent--; + newline(); + emit('}'); + } + + void printDefun(Ref node) { + emit("function "); + emit(node[1]->getCString()); + emit('('); + Ref args = node[2]; + for (size_t i = 0; i < args->size(); i++) { + if (i > 0) { + (pretty ? emit(", ") : emit(',')); + } + emit(args[i]->getCString()); + } + emit(')'); + space(); + if (node->size() == 3 || node[3]->size() == 0) { + emit("{}"); + return; + } + emit('{'); + indent++; + newline(); + printStats(node[3]); + indent--; + newline(); + emit('}'); + newline(); + } + + void printAssign(Ref node) { + auto* assign = node->asAssign(); + printChild(assign->target(), node, -1); + space(); + emit('='); + space(); + printChild(assign->value(), node, 1); + } + + void printAssignName(Ref node) { + auto* assign = node->asAssignName(); + emit(assign->target().c_str()); + space(); + emit('='); + space(); + printChild(assign->value(), node, 1); + } + + void printName(Ref node) { emit(node->getCString()); } + + static char* numToString(double d, bool finalize = true) { + // If this number is NaN or infinite then things are a bit tricky. In JS we + // want to eventually use `NaN` and/or `Infinity`, but neither of those + // identifiers are valid in asm.js. Instead we have to explicitly import + // `NaN` and `Infinity` from the global environment, and those names are + // bound locally in an asm function as `nan` and `infinity`. + // + // TODO: the JS names of `NaN` and `Infinity` should be used once literal + // asm.js code isn't generated any more + if (std::isnan(d)) { + if (std::signbit(d)) { + return (char*)"-nan"; + } else { + return (char*)"nan"; + } + } else if (!std::isfinite(d)) { + if (std::signbit(d)) { + return (char*)"-infinity"; + } else { + return (char*)"infinity"; + } + } + bool neg = d < 0; + if (neg) { + d = -d; + } + // try to emit the fewest necessary characters + bool integer = wasm::isInteger(d); +#define BUFFERSIZE 1000 + // f is normal, e is scientific for float, x for integer + static char full_storage_f[BUFFERSIZE], full_storage_e[BUFFERSIZE]; + // full has one more char, for a possible '-' + static char *storage_f = full_storage_f + 1, + *storage_e = full_storage_e + 1; + auto err_f = std::numeric_limits::quiet_NaN(); + auto err_e = std::numeric_limits::quiet_NaN(); + for (int e = 0; e <= 1; e++) { + char* buffer = e ? storage_e : storage_f; + double temp; + if (!integer) { + static char format[6]; + for (int i = 0; i <= 18; i++) { + format[0] = '%'; + format[1] = '.'; + if (i < 10) { + format[2] = '0' + i; + format[3] = e ? 'e' : 'f'; + format[4] = 0; + } else { + format[2] = '1'; + format[3] = '0' + (i - 10); + format[4] = e ? 'e' : 'f'; + format[5] = 0; + } + snprintf(buffer, BUFFERSIZE - 1, format, d); + sscanf(buffer, "%lf", &temp); + // errv("%.18f, %.18e => %s => %.18f, %.18e (%d), ", d, d, + // buffer, temp, temp, temp == d); + if (temp == d) { + break; + } + } + } else { + // integer + assert(d >= 0); + if (wasm::isUInteger64(d)) { + unsigned long long uu = wasm::toUInteger64(d); + bool asHex = e && !finalize; + snprintf(buffer, BUFFERSIZE - 1, asHex ? "0x%llx" : "%llu", uu); + if (asHex) { + unsigned long long tempULL; + sscanf(buffer, "%llx", &tempULL); + temp = (double)tempULL; + } else { + sscanf(buffer, "%lf", &temp); + } + } else { + // too large for a machine integer, just use floats + // even on integers, e with a dot is useful, e.g. 1.2e+200 + snprintf(buffer, BUFFERSIZE - 1, e ? "%e" : "%.0f", d); + sscanf(buffer, "%lf", &temp); + } + // errv("%.18f, %.18e => %s => %.18f, %.18e, %llu (%d)\n", d, + // d, buffer, temp, temp, uu, temp == d); + } + (e ? err_e : err_f) = fabs(temp - d); + // errv("current attempt: %.18f => %s", d, buffer); + // assert(temp == d); + char* dot = strchr(buffer, '.'); + if (dot) { + // remove trailing zeros + char* end = dot + 1; + while (*end >= '0' && *end <= '9') { + end++; + } + end--; + while (*end == '0') { + char* copy = end; + do { + copy[0] = copy[1]; + } while (*copy++ != 0); + end--; + } + // errv("%.18f => %s", d, buffer); + // remove preceding zeros + while (*buffer == '0') { + char* copy = buffer; + do { + copy[0] = copy[1]; + } while (*copy++ != 0); + } + // errv("%.18f ===> %s", d, buffer); + } else if (!integer || !e) { + // no dot. try to change 12345000 => 12345e3 + char* end = strchr(buffer, 0); + end--; + char* test = end; + // remove zeros, and also doubles can use at most 24 digits, we can + // truncate any extras even if not zero + while ((*test == '0' || test - buffer > 24) && test > buffer) { + test--; + } + int num = end - test; + if (num >= 3) { + test++; + test[0] = 'e'; + if (num < 10) { + test[1] = '0' + num; + test[2] = 0; + } else if (num < 100) { + test[1] = '0' + (num / 10); + test[2] = '0' + (num % 10); + test[3] = 0; + } else { + assert(num < 1000); + test[1] = '0' + (num / 100); + test[2] = '0' + (num % 100) / 10; + test[3] = '0' + (num % 10); + test[4] = 0; + } + } + } + // errv("..current attempt: %.18f => %s", d, buffer); + } + // fprintf(stderr, "options:\n%s\n%s\n (first? %d)\n", storage_e, storage_f, + // strlen(storage_e) < strlen(storage_f)); + char* ret; + if (err_e == err_f) { + ret = strlen(storage_e) < strlen(storage_f) ? storage_e : storage_f; + } else { + ret = err_e < err_f ? storage_e : storage_f; + } + if (neg) { + ret--; // safe to go back one, there is one more char in full_* + *ret = '-'; + } + return ret; + } + + void printNum(Ref node) { + if (node->getNumber() < 0 && buffer[used - 1] == '-') { + emit(' '); // cannot join - and - to --, looks like the -- operator + } + emit(numToString(node->getNumber(), finalize)); + } + + void printString(Ref node) { + emit('"'); + emit(node[1]->getCString()); + emit('"'); + } + + // Parens optimizing + + bool capturesOperators(Ref node) { + Ref type = node[0]; + return type == CALL || type == ARRAY || type == OBJECT || type == SEQ; + } + + int getPrecedence(Ref node, bool parent) { + if (node->isAssign() || node->isAssignName()) { + return OperatorClass::getPrecedence(OperatorClass::Binary, SET); + } + if (!node->isArray()) { + // node is a value + return -1; + } + Ref type = node[0]; + if (type == BINARY || type == UNARY_PREFIX) { + return OperatorClass::getPrecedence( + type == BINARY ? OperatorClass::Binary : OperatorClass::Prefix, + node[1]->getIString()); + } else if (type == SEQ) { + return OperatorClass::getPrecedence(OperatorClass::Binary, COMMA); + } else if (type == CALL) { + // call arguments are split by commas, but call itself is safe + return parent ? OperatorClass::getPrecedence(OperatorClass::Binary, COMMA) + : -1; + } else if (type == CONDITIONAL) { + return OperatorClass::getPrecedence(OperatorClass::Tertiary, QUESTION); + } + // otherwise, this is something that fixes precedence explicitly, and we can + // ignore + return -1; // XXX + } + + // check whether we need parens for the child, when rendered in the parent + // @param childPosition -1 means it is printed to the left of parent, 0 means + // "anywhere", 1 means right + bool needParens(Ref parent, Ref child, int childPosition) { + int parentPrecedence = getPrecedence(parent, true); + int childPrecedence = getPrecedence(child, false); + + if (childPrecedence > parentPrecedence) { + return true; // child is definitely a danger + } + if (childPrecedence < parentPrecedence) { + return false; // definitely cool + } + // equal precedence, so associativity (rtl/ltr) is what matters + // (except for some exceptions, where multiple operators can combine into + // confusion) + if (parent->isArray() && parent[0] == UNARY_PREFIX) { + assert(child[0] == UNARY_PREFIX); + if ((parent[1] == PLUS || parent[1] == MINUS) && child[1] == parent[1]) { + // cannot emit ++x when we mean +(+x) + return true; + } + } + if (childPosition == 0) { + return true; // child could be anywhere, so always paren + } + if (childPrecedence < 0) { + return false; // both precedences are safe + } + // check if child is on the dangerous side + if (OperatorClass::getRtl(parentPrecedence)) { + return childPosition < 0; + } else { + return childPosition > 0; + } + } + + void printChild(Ref child, Ref parent, int childPosition = 0) { + bool parens = needParens(parent, child, childPosition); + if (parens) { + emit('('); + } + print(child); + if (parens) { + emit(')'); + } + } + + void printBinary(Ref node) { + printChild(node[2], node, -1); + space(); + emit(node[1]->getCString()); + space(); + printChild(node[3], node, 1); + } + + void printUnaryPrefix(Ref node) { + if (finalize && node[1] == PLUS && + (node[2]->isNumber() || + (node[2]->isArray() && node[2][0] == UNARY_PREFIX && + node[2][1] == MINUS && node[2][2]->isNumber()))) { + // emit a finalized number + int last = used; + print(node[2]); + ensure(1); // we temporarily append a 0 + char* curr = buffer + last; // ensure might invalidate + buffer[used] = 0; + if (strstr(curr, "infinity")) { + return; + } + if (strstr(curr, "nan")) { + return; + } + if (strchr(curr, '.')) { + return; // already a decimal point, all good + } + char* e = strchr(curr, 'e'); + if (!e) { + emit(".0"); + return; + } + ensure(3); + curr = buffer + last; // ensure might invalidate + char* end = strchr(curr, 0); + while (end >= e) { + end[2] = end[0]; + end--; + } + e[0] = '.'; + e[1] = '0'; + used += 2; + return; + } + if ((buffer[used - 1] == '-' && node[1] == MINUS) || + (buffer[used - 1] == '+' && node[1] == PLUS)) { + emit(' '); // cannot join - and - to --, looks like the -- operator + } + emit(node[1]->getCString()); + printChild(node[2], node, 1); + } + + void printConditional(Ref node) { + printChild(node[1], node, -1); + space(); + emit('?'); + space(); + printChild(node[2], node, 0); + space(); + emit(':'); + space(); + printChild(node[3], node, 1); + } + + void printCall(Ref node) { + printChild(node[1], node, 0); + emit('('); + Ref args = node[2]; + for (size_t i = 0; i < args->size(); i++) { + if (i > 0) { + (pretty ? emit(", ") : emit(',')); + } + printChild(args[i], node, 0); + } + emit(')'); + } + + void printSeq(Ref node) { + printChild(node[1], node, -1); + emit(','); + space(); + printChild(node[2], node, 1); + } + + void printDot(Ref node) { + print(node[1]); + emit('.'); + emit(node[2]->getCString()); + } + + void printSwitch(Ref node) { + emit("switch"); + space(); + emit('('); + print(node[1]); + emit(')'); + space(); + emit('{'); + newline(); + Ref cases = node[2]; + for (size_t i = 0; i < cases->size(); i++) { + Ref c = cases[i]; + if (!c[0]) { + emit("default:"); + } else { + emit("case "); + print(c[0]); + emit(':'); + } + if (c[1]->size() > 0) { + indent++; + newline(); + auto curr = used; + printStats(c[1]); + indent--; + if (curr != used) { + newline(); + } else { + used--; // avoid the extra indentation we added tentatively + } + } else { + newline(); + } + } + emit('}'); + } + + void printTry(Ref node) { + emit("try "); + printBlock(node[1]); + emit(" catch ("); + printName(node[2]); + emit(") "); + printBlock(node[3]); + } + + void printSub(Ref node) { + printChild(node[1], node, -1); + emit('['); + print(node[2]); + emit(']'); + } + + void printVar(Ref node) { + emit("var "); + Ref args = node[1]; + for (size_t i = 0; i < args->size(); i++) { + if (i > 0) { + (pretty ? emit(", ") : emit(',')); + } + emit(args[i][0]->getCString()); + if (args[i]->size() > 1) { + space(); + emit('='); + space(); + print(args[i][1]); + } + } + } + + static bool isBlock(Ref node) { + return node->isArray() && !node->empty() && node[0] == BLOCK; + } + + static bool ifHasElse(Ref node) { + assert(node->isArray() && node[0] == IF); + return node->size() >= 4 && !!node[3]; + } + + void printIf(Ref node) { + emit("if"); + safeSpace(); + emit('('); + print(node[1]); + emit(')'); + space(); + bool emitsBracesAnyhow = isBlock(node[2]); + if (!emitsBracesAnyhow) { + emit('{'); + indent++; + newline(); + } + print(node[2]); + if (!emitsBracesAnyhow) { + indent--; + newline(); + emit('}'); + } + if (ifHasElse(node)) { + space(); + emit("else"); + safeSpace(); + bool emitsBracesAnyhow = isBlock(node[3]); + if (!emitsBracesAnyhow) { + emit('{'); + indent++; + newline(); + } + print(node[3]); + if (!emitsBracesAnyhow) { + indent--; + newline(); + emit('}'); + } + } + } + + void printDo(Ref node) { + emit("do"); + safeSpace(); + print(node[2], "{}"); + space(); + emit("while"); + space(); + emit('('); + print(node[1]); + emit(')'); + } + + void printWhile(Ref node) { + emit("while"); + space(); + emit('('); + print(node[1]); + emit(')'); + space(); + print(node[2], "{}"); + } + + void printLabel(Ref node) { + emit(node[1]->getCString()); + space(); + emit(':'); + space(); + print(node[2]); + } + + void printReturn(Ref node) { + emit("return"); + if (!!node[1]) { + emit(' '); + print(node[1]); + } + } + + void printBreak(Ref node) { + emit("break"); + if (!!node[1]) { + emit(' '); + emit(node[1]->getCString()); + } + } + + void printContinue(Ref node) { + emit("continue"); + if (!!node[1]) { + emit(' '); + emit(node[1]->getCString()); + } + } + + void printNew(Ref node) { + emit("new "); + print(node[1]); + } + + void printArray(Ref node) { + emit('['); + Ref args = node[1]; + for (size_t i = 0; i < args->size(); i++) { + if (i > 0) { + (pretty ? emit(", ") : emit(',')); + } + print(args[i]); + } + emit(']'); + } + + void printObject(Ref node) { + emit('{'); + indent++; + newline(); + Ref args = node[1]; + for (size_t i = 0; i < args->size(); i++) { + if (i > 0) { + pretty ? emit(", ") : emit(','); + newline(); + } + bool needQuote = false; + const char* str; + if (args[i][0]->isArray()) { + assert(args[i][0][0] == STRING); + // A quoted string. + needQuote = true; + str = args[i][0][1]->getCString(); + } else { + // Just a raw string, no quotes. + str = args[i][0]->getCString(); + } + const char* check = str; + while (*check) { + if (!isalnum(*check) && *check != '_' && *check != '$') { + needQuote = true; + break; + } + check++; + } + if (needQuote) { + emit('"'); + } + emit(str); + if (needQuote) { + emit('"'); + } + emit(":"); + space(); + print(args[i][1]); + } + indent--; + newline(); + emit('}'); + } +}; + +// cashew builder + +class ValueBuilder { + static Ref makeRawString(const IString& s) { + return &arena.alloc()->setString(s); + } + + static Ref makeNull() { return &arena.alloc()->setNull(); } + +public: + static Ref makeRawArray(int size_hint = 0) { + return &arena.alloc()->setArray(size_hint); + } + + static Ref makeToplevel() { + return &makeRawArray(2) + ->push_back(makeRawString(TOPLEVEL)) + .push_back(makeRawArray()); + } + + static Ref makeString(IString str) { + return &makeRawArray(2) + ->push_back(makeRawString(STRING)) + .push_back(makeRawString(str)); + } + + static Ref makeBlock() { + return &makeRawArray(2) + ->push_back(makeRawString(BLOCK)) + .push_back(makeRawArray()); + } + + static Ref makeName(IString name) { return makeRawString(name); } + + static void setBlockContent(Ref target, Ref block) { + if (target[0] == TOPLEVEL) { + target[1]->setArray(block[1]->getArray()); + } else if (target[0] == DEFUN) { + target[3]->setArray(block[1]->getArray()); + } else { + abort(); + } + } + + static void appendToBlock(Ref block, Ref element) { + assert(block[0] == BLOCK); + block[1]->push_back(element); + } + + static Ref makeCall(Ref target) { + return &makeRawArray(3) + ->push_back(makeRawString(CALL)) + .push_back(target) + .push_back(makeRawArray()); + } + static Ref makeCall(Ref target, Ref arg) { + Ref ret = &makeRawArray(3) + ->push_back(makeRawString(CALL)) + .push_back(target) + .push_back(makeRawArray()); + ret[2]->push_back(arg); + return ret; + } + static Ref makeCall(IString target) { + Ref ret = &makeRawArray(3) + ->push_back(makeRawString(CALL)) + .push_back(makeName(target)) + .push_back(makeRawArray()); + return ret; + } + + template static Ref makeCall(IString target, Ts... args) { + size_t nArgs = sizeof...(Ts); + Ref callArgs = makeRawArray(nArgs); + Ref argArray[] = {args...}; + for (size_t i = 0; i < nArgs; ++i) { + callArgs->push_back(argArray[i]); + } + return &makeRawArray(3) + ->push_back(makeRawString(CALL)) + .push_back(makeName(target)) + .push_back(callArgs); + } + + static void appendToCall(Ref call, Ref element) { + assert(call[0] == CALL); + call[2]->push_back(element); + } + + static Ref makeStatement(Ref contents) { return contents; } + + static Ref makeDouble(double num) { + return &arena.alloc()->setNumber(num); + } + static Ref makeInt(uint32_t num) { return makeDouble(double(num)); } + static Ref makeInt(int32_t num) { return makeDouble(double(num)); } + static Ref makeNum(double num) { return makeDouble(num); } + + static Ref makeUnary(IString op, Ref value) { + return &makeRawArray(3) + ->push_back(makeRawString(UNARY_PREFIX)) + .push_back(makeRawString(op)) + .push_back(value); + } + + static Ref makeBinary(Ref left, IString op, Ref right) { + if (op == SET) { + if (left->isString()) { + return &arena.alloc()->setAssignName(left->getIString(), + right); + } else { + return &arena.alloc()->setAssign(left, right); + } + } else if (op == COMMA) { + return &makeRawArray(3) + ->push_back(makeRawString(SEQ)) + .push_back(left) + .push_back(right); + } else { + return &makeRawArray(4) + ->push_back(makeRawString(BINARY)) + .push_back(makeRawString(op)) + .push_back(left) + .push_back(right); + } + } + + static Ref makePrefix(IString op, Ref right) { + return &makeRawArray(3) + ->push_back(makeRawString(UNARY_PREFIX)) + .push_back(makeRawString(op)) + .push_back(right); + } + + static Ref makeFunction(IString name) { + return &makeRawArray(4) + ->push_back(makeRawString(DEFUN)) + .push_back(makeRawString(name)) + .push_back(makeRawArray()) + .push_back(makeRawArray()); + } + + static void appendArgumentToFunction(Ref func, IString arg) { + assert(func[0] == DEFUN); + func[2]->push_back(makeRawString(arg)); + } + + static Ref makeVar(bool is_const = false) { + return &makeRawArray(2) + ->push_back(makeRawString(VAR)) + .push_back(makeRawArray()); + } + + static void appendToVar(Ref var, IString name, Ref value) { + assert(var[0] == VAR); + Ref array = &makeRawArray(1)->push_back(makeRawString(name)); + if (!!value) { + array->push_back(value); + } + var[1]->push_back(array); + } + + static Ref makeReturn(Ref value) { + return &makeRawArray(2) + ->push_back(makeRawString(RETURN)) + .push_back(!!value ? value : makeNull()); + } + + static Ref makeIndexing(Ref target, Ref index) { + return &makeRawArray(3) + ->push_back(makeRawString(SUB)) + .push_back(target) + .push_back(index); + } + + static Ref makeIf(Ref condition, Ref ifTrue, Ref ifFalse) { + return &makeRawArray(4) + ->push_back(makeRawString(IF)) + .push_back(condition) + .push_back(ifTrue) + .push_back(!!ifFalse ? ifFalse : makeNull()); + } + + static Ref makeConditional(Ref condition, Ref ifTrue, Ref ifFalse) { + return &makeRawArray(4) + ->push_back(makeRawString(CONDITIONAL)) + .push_back(condition) + .push_back(ifTrue) + .push_back(ifFalse); + } + + static Ref makeSeq(Ref left, Ref right) { + return &makeRawArray(3) + ->push_back(makeRawString(SEQ)) + .push_back(left) + .push_back(right); + } + + static Ref makeDo(Ref body, Ref condition) { + return &makeRawArray(3) + ->push_back(makeRawString(DO)) + .push_back(condition) + .push_back(body); + } + + static Ref makeWhile(Ref condition, Ref body) { + return &makeRawArray(3) + ->push_back(makeRawString(WHILE)) + .push_back(condition) + .push_back(body); + } + + static Ref makeFor(Ref init, Ref condition, Ref inc, Ref body) { + return &makeRawArray(5) + ->push_back(makeRawString(FOR)) + .push_back(init) + .push_back(condition) + .push_back(inc) + .push_back(body); + } + + static Ref makeBreak(IString label) { + return &makeRawArray(2) + ->push_back(makeRawString(BREAK)) + .push_back(!!label ? makeRawString(label) : makeNull()); + } + + static Ref makeContinue(IString label) { + return &makeRawArray(2) + ->push_back(makeRawString(CONTINUE)) + .push_back(!!label ? makeRawString(label) : makeNull()); + } + + static Ref makeLabel(IString name, Ref body) { + return &makeRawArray(3) + ->push_back(makeRawString(LABEL)) + .push_back(makeRawString(name)) + .push_back(body); + } + + static Ref makeSwitch(Ref input) { + return &makeRawArray(3) + ->push_back(makeRawString(SWITCH)) + .push_back(input) + .push_back(makeRawArray()); + } + + static void appendCaseToSwitch(Ref switch_, Ref arg) { + assert(switch_[0] == SWITCH); + switch_[2]->push_back( + &makeRawArray(2)->push_back(arg).push_back(makeRawArray())); + } + + static void appendDefaultToSwitch(Ref switch_) { + assert(switch_[0] == SWITCH); + switch_[2]->push_back( + &makeRawArray(2)->push_back(makeNull()).push_back(makeRawArray())); + } + + static void appendCodeToSwitch(Ref switch_, Ref code, bool explicitBlock) { + assert(switch_[0] == SWITCH); + assert(code[0] == BLOCK); + if (!explicitBlock) { + for (size_t i = 0; i < code[1]->size(); i++) { + switch_[2]->back()->back()->push_back(code[1][i]); + } + } else { + switch_[2]->back()->back()->push_back(code); + } + } + + static Ref makeTry(Ref try_, Ref arg, Ref catch_) { + assert(try_[0] == BLOCK); + assert(catch_[0] == BLOCK); + return &makeRawArray(3) + ->push_back(makeRawString(TRY)) + .push_back(try_) + .push_back(arg) + .push_back(catch_); + } + + static Ref makeDot(Ref obj, IString key) { + return &makeRawArray(3) + ->push_back(makeRawString(DOT)) + .push_back(obj) + .push_back(makeRawString(key)); + } + + template static Ref makeDot(Ref obj, Ref key, Ts... args) { + return makeDot(makeDot(obj, key), args...); + } + + static Ref makeDot(Ref obj, Ref key) { + assert(key->isString()); + return makeDot(obj, key->getIString()); + } + + static Ref makeNew(Ref call) { + return &makeRawArray(2)->push_back(makeRawString(NEW)).push_back(call); + } + + static Ref makeArray() { + return &makeRawArray(2) + ->push_back(makeRawString(ARRAY)) + .push_back(makeRawArray()); + } + + static void appendToArray(Ref array, Ref element) { + assert(array[0] == ARRAY); + array[1]->push_back(element); + } + + static Ref makeObject() { + return &makeRawArray(2) + ->push_back(makeRawString(OBJECT)) + .push_back(makeRawArray()); + } + + static void appendToObject(Ref array, IString key, Ref value) { + assert(array[0] == OBJECT); + array[1]->push_back( + &makeRawArray(2)->push_back(makeRawString(key)).push_back(value)); + } + + static void appendToObjectWithQuotes(Ref array, IString key, Ref value) { + assert(array[0] == OBJECT); + array[1]->push_back( + &makeRawArray(2)->push_back(makeString(key)).push_back(value)); + } + + static Ref makeSub(Ref obj, Ref index) { + return &makeRawArray(2) + ->push_back(makeRawString(SUB)) + .push_back(obj) + .push_back(index); + } + + static Ref makePtrShift(Ref ptr, int shifts) { + return makeBinary(ptr, RSHIFT, makeInt(shifts)); + } +}; + +// Tolerates 0.0 in the input; does not trust a +() to be there. +class DotZeroValueBuilder : public ValueBuilder { +public: + static Ref makeDouble(double num) { + return makePrefix(PLUS, ValueBuilder::makeDouble(num)); + } +}; + +} // namespace cashew + +#endif // wasm_simple_ast_h diff --git a/binaryen/src/emscripten-optimizer/snprintf.h b/binaryen/src/emscripten-optimizer/snprintf.h new file mode 100644 --- /dev/null +++ b/binaryen/src/emscripten-optimizer/snprintf.h @@ -0,0 +1,53 @@ +/* + * Copyright 2015 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef wasm_snprintf_h +#define wasm_snprintf_h + +#include + +// Visual Studio does not support C99, so emulate snprintf support for it +// manually. + +#ifdef _MSC_VER + +#define snprintf c99_snprintf + +inline int +c99_vsnprintf(char* str, size_t size, const char* format, va_list ap) { + int count = -1; + + if (size != 0) + count = _vsnprintf_s(str, size, _TRUNCATE, format, ap); + if (count == -1) + count = _vscprintf(format, ap); + + return count; +} + +inline int c99_snprintf(char* str, size_t size, const char* format, ...) { + int count; + va_list ap; + + va_start(ap, format); + count = c99_vsnprintf(str, size, format, ap); + va_end(ap); + + return count; +} +#endif + +#endif // wasm_snprintf_h diff --git a/binaryen/src/gen-s-parser.inc b/binaryen/src/gen-s-parser.inc new file mode 100644 --- /dev/null +++ b/binaryen/src/gen-s-parser.inc @@ -0,0 +1,2843 @@ +// DO NOT EDIT! This file generated by scripts/gen-s-parser.py + +// clang-format off + +#ifdef INSTRUCTION_PARSER +#undef INSTRUCTION_PARSER +char op[28] = {'\0'}; +strncpy(op, s[0]->c_str(), 27); +switch (op[0]) { + case 'a': { + switch (op[1]) { + case 'r': { + switch (op[6]) { + case 'g': { + switch (op[9]) { + case '\0': + if (strcmp(op, "array.get") == 0) { return makeArrayGet(s); } + goto parse_error; + case '_': { + switch (op[10]) { + case 's': + if (strcmp(op, "array.get_s") == 0) { return makeArrayGet(s, true); } + goto parse_error; + case 'u': + if (strcmp(op, "array.get_u") == 0) { return makeArrayGet(s, false); } + goto parse_error; + default: goto parse_error; + } + } + default: goto parse_error; + } + } + case 'l': + if (strcmp(op, "array.len") == 0) { return makeArrayLen(s); } + goto parse_error; + case 'n': { + switch (op[10]) { + case 'd': + if (strcmp(op, "array.new_default_with_rtt") == 0) { return makeArrayNew(s, true); } + goto parse_error; + case 'w': + if (strcmp(op, "array.new_with_rtt") == 0) { return makeArrayNew(s, false); } + goto parse_error; + default: goto parse_error; + } + } + case 's': + if (strcmp(op, "array.set") == 0) { return makeArraySet(s); } + goto parse_error; + default: goto parse_error; + } + } + case 't': { + switch (op[7]) { + case 'f': + if (strcmp(op, "atomic.fence") == 0) { return makeAtomicFence(s); } + goto parse_error; + case 'n': + if (strcmp(op, "atomic.notify") == 0) { return makeAtomicNotify(s); } + goto parse_error; + default: goto parse_error; + } + } + default: goto parse_error; + } + } + case 'b': { + switch (op[1]) { + case 'l': + if (strcmp(op, "block") == 0) { return makeBlock(s); } + goto parse_error; + case 'r': { + switch (op[2]) { + case '\0': + if (strcmp(op, "br") == 0) { return makeBreak(s); } + goto parse_error; + case '_': { + switch (op[3]) { + case 'i': + if (strcmp(op, "br_if") == 0) { return makeBreak(s); } + goto parse_error; + case 'o': { + switch (op[6]) { + case 'c': + if (strcmp(op, "br_on_cast") == 0) { return makeBrOnCast(s); } + goto parse_error; + case 'e': + if (strcmp(op, "br_on_exn") == 0) { return makeBrOnExn(s); } + goto parse_error; + default: goto parse_error; + } + } + case 't': + if (strcmp(op, "br_table") == 0) { return makeBreakTable(s); } + goto parse_error; + default: goto parse_error; + } + } + default: goto parse_error; + } + } + default: goto parse_error; + } + } + case 'c': { + switch (op[4]) { + case '\0': + if (strcmp(op, "call") == 0) { return makeCall(s, /*isReturn=*/false); } + goto parse_error; + case '_': + if (strcmp(op, "call_indirect") == 0) { return makeCallIndirect(s, /*isReturn=*/false); } + goto parse_error; + default: goto parse_error; + } + } + case 'd': { + switch (op[1]) { + case 'a': + if (strcmp(op, "data.drop") == 0) { return makeDataDrop(s); } + goto parse_error; + case 'r': + if (strcmp(op, "drop") == 0) { return makeDrop(s); } + goto parse_error; + default: goto parse_error; + } + } + case 'e': + if (strcmp(op, "else") == 0) { return makeThenOrElse(s); } + goto parse_error; + case 'f': { + switch (op[1]) { + case '3': { + switch (op[3]) { + case '.': { + switch (op[4]) { + case 'a': { + switch (op[5]) { + case 'b': + if (strcmp(op, "f32.abs") == 0) { return makeUnary(s, UnaryOp::AbsFloat32); } + goto parse_error; + case 'd': + if (strcmp(op, "f32.add") == 0) { return makeBinary(s, BinaryOp::AddFloat32); } + goto parse_error; + default: goto parse_error; + } + } + case 'c': { + switch (op[5]) { + case 'e': + if (strcmp(op, "f32.ceil") == 0) { return makeUnary(s, UnaryOp::CeilFloat32); } + goto parse_error; + case 'o': { + switch (op[6]) { + case 'n': { + switch (op[7]) { + case 's': + if (strcmp(op, "f32.const") == 0) { return makeConst(s, Type::f32); } + goto parse_error; + case 'v': { + switch (op[13]) { + case '3': { + switch (op[16]) { + case 's': + if (strcmp(op, "f32.convert_i32_s") == 0) { return makeUnary(s, UnaryOp::ConvertSInt32ToFloat32); } + goto parse_error; + case 'u': + if (strcmp(op, "f32.convert_i32_u") == 0) { return makeUnary(s, UnaryOp::ConvertUInt32ToFloat32); } + goto parse_error; + default: goto parse_error; + } + } + case '6': { + switch (op[16]) { + case 's': + if (strcmp(op, "f32.convert_i64_s") == 0) { return makeUnary(s, UnaryOp::ConvertSInt64ToFloat32); } + goto parse_error; + case 'u': + if (strcmp(op, "f32.convert_i64_u") == 0) { return makeUnary(s, UnaryOp::ConvertUInt64ToFloat32); } + goto parse_error; + default: goto parse_error; + } + } + default: goto parse_error; + } + } + default: goto parse_error; + } + } + case 'p': + if (strcmp(op, "f32.copysign") == 0) { return makeBinary(s, BinaryOp::CopySignFloat32); } + goto parse_error; + default: goto parse_error; + } + } + default: goto parse_error; + } + } + case 'd': { + switch (op[5]) { + case 'e': + if (strcmp(op, "f32.demote_f64") == 0) { return makeUnary(s, UnaryOp::DemoteFloat64); } + goto parse_error; + case 'i': + if (strcmp(op, "f32.div") == 0) { return makeBinary(s, BinaryOp::DivFloat32); } + goto parse_error; + default: goto parse_error; + } + } + case 'e': + if (strcmp(op, "f32.eq") == 0) { return makeBinary(s, BinaryOp::EqFloat32); } + goto parse_error; + case 'f': + if (strcmp(op, "f32.floor") == 0) { return makeUnary(s, UnaryOp::FloorFloat32); } + goto parse_error; + case 'g': { + switch (op[5]) { + case 'e': + if (strcmp(op, "f32.ge") == 0) { return makeBinary(s, BinaryOp::GeFloat32); } + goto parse_error; + case 't': + if (strcmp(op, "f32.gt") == 0) { return makeBinary(s, BinaryOp::GtFloat32); } + goto parse_error; + default: goto parse_error; + } + } + case 'l': { + switch (op[5]) { + case 'e': + if (strcmp(op, "f32.le") == 0) { return makeBinary(s, BinaryOp::LeFloat32); } + goto parse_error; + case 'o': + if (strcmp(op, "f32.load") == 0) { return makeLoad(s, Type::f32, /*isAtomic=*/false); } + goto parse_error; + case 't': + if (strcmp(op, "f32.lt") == 0) { return makeBinary(s, BinaryOp::LtFloat32); } + goto parse_error; + default: goto parse_error; + } + } + case 'm': { + switch (op[5]) { + case 'a': + if (strcmp(op, "f32.max") == 0) { return makeBinary(s, BinaryOp::MaxFloat32); } + goto parse_error; + case 'i': + if (strcmp(op, "f32.min") == 0) { return makeBinary(s, BinaryOp::MinFloat32); } + goto parse_error; + case 'u': + if (strcmp(op, "f32.mul") == 0) { return makeBinary(s, BinaryOp::MulFloat32); } + goto parse_error; + default: goto parse_error; + } + } + case 'n': { + switch (op[6]) { + case '\0': + if (strcmp(op, "f32.ne") == 0) { return makeBinary(s, BinaryOp::NeFloat32); } + goto parse_error; + case 'a': + if (strcmp(op, "f32.nearest") == 0) { return makeUnary(s, UnaryOp::NearestFloat32); } + goto parse_error; + case 'g': + if (strcmp(op, "f32.neg") == 0) { return makeUnary(s, UnaryOp::NegFloat32); } + goto parse_error; + default: goto parse_error; + } + } + case 'r': + if (strcmp(op, "f32.reinterpret_i32") == 0) { return makeUnary(s, UnaryOp::ReinterpretInt32); } + goto parse_error; + case 's': { + switch (op[5]) { + case 'q': + if (strcmp(op, "f32.sqrt") == 0) { return makeUnary(s, UnaryOp::SqrtFloat32); } + goto parse_error; + case 't': + if (strcmp(op, "f32.store") == 0) { return makeStore(s, Type::f32, /*isAtomic=*/false); } + goto parse_error; + case 'u': + if (strcmp(op, "f32.sub") == 0) { return makeBinary(s, BinaryOp::SubFloat32); } + goto parse_error; + default: goto parse_error; + } + } + case 't': + if (strcmp(op, "f32.trunc") == 0) { return makeUnary(s, UnaryOp::TruncFloat32); } + goto parse_error; + default: goto parse_error; + } + } + case 'x': { + switch (op[6]) { + case 'a': { + switch (op[7]) { + case 'b': + if (strcmp(op, "f32x4.abs") == 0) { return makeUnary(s, UnaryOp::AbsVecF32x4); } + goto parse_error; + case 'd': + if (strcmp(op, "f32x4.add") == 0) { return makeBinary(s, BinaryOp::AddVecF32x4); } + goto parse_error; + default: goto parse_error; + } + } + case 'c': { + switch (op[7]) { + case 'e': + if (strcmp(op, "f32x4.ceil") == 0) { return makeUnary(s, UnaryOp::CeilVecF32x4); } + goto parse_error; + case 'o': { + switch (op[20]) { + case 's': + if (strcmp(op, "f32x4.convert_i32x4_s") == 0) { return makeUnary(s, UnaryOp::ConvertSVecI32x4ToVecF32x4); } + goto parse_error; + case 'u': + if (strcmp(op, "f32x4.convert_i32x4_u") == 0) { return makeUnary(s, UnaryOp::ConvertUVecI32x4ToVecF32x4); } + goto parse_error; + default: goto parse_error; + } + } + default: goto parse_error; + } + } + case 'd': + if (strcmp(op, "f32x4.div") == 0) { return makeBinary(s, BinaryOp::DivVecF32x4); } + goto parse_error; + case 'e': { + switch (op[7]) { + case 'q': + if (strcmp(op, "f32x4.eq") == 0) { return makeBinary(s, BinaryOp::EqVecF32x4); } + goto parse_error; + case 'x': + if (strcmp(op, "f32x4.extract_lane") == 0) { return makeSIMDExtract(s, SIMDExtractOp::ExtractLaneVecF32x4, 4); } + goto parse_error; + default: goto parse_error; + } + } + case 'f': + if (strcmp(op, "f32x4.floor") == 0) { return makeUnary(s, UnaryOp::FloorVecF32x4); } + goto parse_error; + case 'g': { + switch (op[7]) { + case 'e': + if (strcmp(op, "f32x4.ge") == 0) { return makeBinary(s, BinaryOp::GeVecF32x4); } + goto parse_error; + case 't': + if (strcmp(op, "f32x4.gt") == 0) { return makeBinary(s, BinaryOp::GtVecF32x4); } + goto parse_error; + default: goto parse_error; + } + } + case 'l': { + switch (op[7]) { + case 'e': + if (strcmp(op, "f32x4.le") == 0) { return makeBinary(s, BinaryOp::LeVecF32x4); } + goto parse_error; + case 't': + if (strcmp(op, "f32x4.lt") == 0) { return makeBinary(s, BinaryOp::LtVecF32x4); } + goto parse_error; + default: goto parse_error; + } + } + case 'm': { + switch (op[7]) { + case 'a': + if (strcmp(op, "f32x4.max") == 0) { return makeBinary(s, BinaryOp::MaxVecF32x4); } + goto parse_error; + case 'i': + if (strcmp(op, "f32x4.min") == 0) { return makeBinary(s, BinaryOp::MinVecF32x4); } + goto parse_error; + case 'u': + if (strcmp(op, "f32x4.mul") == 0) { return makeBinary(s, BinaryOp::MulVecF32x4); } + goto parse_error; + default: goto parse_error; + } + } + case 'n': { + switch (op[8]) { + case '\0': + if (strcmp(op, "f32x4.ne") == 0) { return makeBinary(s, BinaryOp::NeVecF32x4); } + goto parse_error; + case 'a': + if (strcmp(op, "f32x4.nearest") == 0) { return makeUnary(s, UnaryOp::NearestVecF32x4); } + goto parse_error; + case 'g': + if (strcmp(op, "f32x4.neg") == 0) { return makeUnary(s, UnaryOp::NegVecF32x4); } + goto parse_error; + default: goto parse_error; + } + } + case 'p': { + switch (op[8]) { + case 'a': + if (strcmp(op, "f32x4.pmax") == 0) { return makeBinary(s, BinaryOp::PMaxVecF32x4); } + goto parse_error; + case 'i': + if (strcmp(op, "f32x4.pmin") == 0) { return makeBinary(s, BinaryOp::PMinVecF32x4); } + goto parse_error; + default: goto parse_error; + } + } + case 'q': { + switch (op[9]) { + case 'a': + if (strcmp(op, "f32x4.qfma") == 0) { return makeSIMDTernary(s, SIMDTernaryOp::QFMAF32x4); } + goto parse_error; + case 's': + if (strcmp(op, "f32x4.qfms") == 0) { return makeSIMDTernary(s, SIMDTernaryOp::QFMSF32x4); } + goto parse_error; + default: goto parse_error; + } + } + case 'r': + if (strcmp(op, "f32x4.replace_lane") == 0) { return makeSIMDReplace(s, SIMDReplaceOp::ReplaceLaneVecF32x4, 4); } + goto parse_error; + case 's': { + switch (op[7]) { + case 'p': + if (strcmp(op, "f32x4.splat") == 0) { return makeUnary(s, UnaryOp::SplatVecF32x4); } + goto parse_error; + case 'q': + if (strcmp(op, "f32x4.sqrt") == 0) { return makeUnary(s, UnaryOp::SqrtVecF32x4); } + goto parse_error; + case 'u': + if (strcmp(op, "f32x4.sub") == 0) { return makeBinary(s, BinaryOp::SubVecF32x4); } + goto parse_error; + default: goto parse_error; + } + } + case 't': + if (strcmp(op, "f32x4.trunc") == 0) { return makeUnary(s, UnaryOp::TruncVecF32x4); } + goto parse_error; + default: goto parse_error; + } + } + default: goto parse_error; + } + } + case '6': { + switch (op[3]) { + case '.': { + switch (op[4]) { + case 'a': { + switch (op[5]) { + case 'b': + if (strcmp(op, "f64.abs") == 0) { return makeUnary(s, UnaryOp::AbsFloat64); } + goto parse_error; + case 'd': + if (strcmp(op, "f64.add") == 0) { return makeBinary(s, BinaryOp::AddFloat64); } + goto parse_error; + default: goto parse_error; + } + } + case 'c': { + switch (op[5]) { + case 'e': + if (strcmp(op, "f64.ceil") == 0) { return makeUnary(s, UnaryOp::CeilFloat64); } + goto parse_error; + case 'o': { + switch (op[6]) { + case 'n': { + switch (op[7]) { + case 's': + if (strcmp(op, "f64.const") == 0) { return makeConst(s, Type::f64); } + goto parse_error; + case 'v': { + switch (op[13]) { + case '3': { + switch (op[16]) { + case 's': + if (strcmp(op, "f64.convert_i32_s") == 0) { return makeUnary(s, UnaryOp::ConvertSInt32ToFloat64); } + goto parse_error; + case 'u': + if (strcmp(op, "f64.convert_i32_u") == 0) { return makeUnary(s, UnaryOp::ConvertUInt32ToFloat64); } + goto parse_error; + default: goto parse_error; + } + } + case '6': { + switch (op[16]) { + case 's': + if (strcmp(op, "f64.convert_i64_s") == 0) { return makeUnary(s, UnaryOp::ConvertSInt64ToFloat64); } + goto parse_error; + case 'u': + if (strcmp(op, "f64.convert_i64_u") == 0) { return makeUnary(s, UnaryOp::ConvertUInt64ToFloat64); } + goto parse_error; + default: goto parse_error; + } + } + default: goto parse_error; + } + } + default: goto parse_error; + } + } + case 'p': + if (strcmp(op, "f64.copysign") == 0) { return makeBinary(s, BinaryOp::CopySignFloat64); } + goto parse_error; + default: goto parse_error; + } + } + default: goto parse_error; + } + } + case 'd': + if (strcmp(op, "f64.div") == 0) { return makeBinary(s, BinaryOp::DivFloat64); } + goto parse_error; + case 'e': + if (strcmp(op, "f64.eq") == 0) { return makeBinary(s, BinaryOp::EqFloat64); } + goto parse_error; + case 'f': + if (strcmp(op, "f64.floor") == 0) { return makeUnary(s, UnaryOp::FloorFloat64); } + goto parse_error; + case 'g': { + switch (op[5]) { + case 'e': + if (strcmp(op, "f64.ge") == 0) { return makeBinary(s, BinaryOp::GeFloat64); } + goto parse_error; + case 't': + if (strcmp(op, "f64.gt") == 0) { return makeBinary(s, BinaryOp::GtFloat64); } + goto parse_error; + default: goto parse_error; + } + } + case 'l': { + switch (op[5]) { + case 'e': + if (strcmp(op, "f64.le") == 0) { return makeBinary(s, BinaryOp::LeFloat64); } + goto parse_error; + case 'o': + if (strcmp(op, "f64.load") == 0) { return makeLoad(s, Type::f64, /*isAtomic=*/false); } + goto parse_error; + case 't': + if (strcmp(op, "f64.lt") == 0) { return makeBinary(s, BinaryOp::LtFloat64); } + goto parse_error; + default: goto parse_error; + } + } + case 'm': { + switch (op[5]) { + case 'a': + if (strcmp(op, "f64.max") == 0) { return makeBinary(s, BinaryOp::MaxFloat64); } + goto parse_error; + case 'i': + if (strcmp(op, "f64.min") == 0) { return makeBinary(s, BinaryOp::MinFloat64); } + goto parse_error; + case 'u': + if (strcmp(op, "f64.mul") == 0) { return makeBinary(s, BinaryOp::MulFloat64); } + goto parse_error; + default: goto parse_error; + } + } + case 'n': { + switch (op[6]) { + case '\0': + if (strcmp(op, "f64.ne") == 0) { return makeBinary(s, BinaryOp::NeFloat64); } + goto parse_error; + case 'a': + if (strcmp(op, "f64.nearest") == 0) { return makeUnary(s, UnaryOp::NearestFloat64); } + goto parse_error; + case 'g': + if (strcmp(op, "f64.neg") == 0) { return makeUnary(s, UnaryOp::NegFloat64); } + goto parse_error; + default: goto parse_error; + } + } + case 'p': + if (strcmp(op, "f64.promote_f32") == 0) { return makeUnary(s, UnaryOp::PromoteFloat32); } + goto parse_error; + case 'r': + if (strcmp(op, "f64.reinterpret_i64") == 0) { return makeUnary(s, UnaryOp::ReinterpretInt64); } + goto parse_error; + case 's': { + switch (op[5]) { + case 'q': + if (strcmp(op, "f64.sqrt") == 0) { return makeUnary(s, UnaryOp::SqrtFloat64); } + goto parse_error; + case 't': + if (strcmp(op, "f64.store") == 0) { return makeStore(s, Type::f64, /*isAtomic=*/false); } + goto parse_error; + case 'u': + if (strcmp(op, "f64.sub") == 0) { return makeBinary(s, BinaryOp::SubFloat64); } + goto parse_error; + default: goto parse_error; + } + } + case 't': + if (strcmp(op, "f64.trunc") == 0) { return makeUnary(s, UnaryOp::TruncFloat64); } + goto parse_error; + default: goto parse_error; + } + } + case 'x': { + switch (op[6]) { + case 'a': { + switch (op[7]) { + case 'b': + if (strcmp(op, "f64x2.abs") == 0) { return makeUnary(s, UnaryOp::AbsVecF64x2); } + goto parse_error; + case 'd': + if (strcmp(op, "f64x2.add") == 0) { return makeBinary(s, BinaryOp::AddVecF64x2); } + goto parse_error; + default: goto parse_error; + } + } + case 'c': { + switch (op[7]) { + case 'e': + if (strcmp(op, "f64x2.ceil") == 0) { return makeUnary(s, UnaryOp::CeilVecF64x2); } + goto parse_error; + case 'o': { + switch (op[20]) { + case 's': + if (strcmp(op, "f64x2.convert_i64x2_s") == 0) { return makeUnary(s, UnaryOp::ConvertSVecI64x2ToVecF64x2); } + goto parse_error; + case 'u': + if (strcmp(op, "f64x2.convert_i64x2_u") == 0) { return makeUnary(s, UnaryOp::ConvertUVecI64x2ToVecF64x2); } + goto parse_error; + default: goto parse_error; + } + } + default: goto parse_error; + } + } + case 'd': + if (strcmp(op, "f64x2.div") == 0) { return makeBinary(s, BinaryOp::DivVecF64x2); } + goto parse_error; + case 'e': { + switch (op[7]) { + case 'q': + if (strcmp(op, "f64x2.eq") == 0) { return makeBinary(s, BinaryOp::EqVecF64x2); } + goto parse_error; + case 'x': + if (strcmp(op, "f64x2.extract_lane") == 0) { return makeSIMDExtract(s, SIMDExtractOp::ExtractLaneVecF64x2, 2); } + goto parse_error; + default: goto parse_error; + } + } + case 'f': + if (strcmp(op, "f64x2.floor") == 0) { return makeUnary(s, UnaryOp::FloorVecF64x2); } + goto parse_error; + case 'g': { + switch (op[7]) { + case 'e': + if (strcmp(op, "f64x2.ge") == 0) { return makeBinary(s, BinaryOp::GeVecF64x2); } + goto parse_error; + case 't': + if (strcmp(op, "f64x2.gt") == 0) { return makeBinary(s, BinaryOp::GtVecF64x2); } + goto parse_error; + default: goto parse_error; + } + } + case 'l': { + switch (op[7]) { + case 'e': + if (strcmp(op, "f64x2.le") == 0) { return makeBinary(s, BinaryOp::LeVecF64x2); } + goto parse_error; + case 't': + if (strcmp(op, "f64x2.lt") == 0) { return makeBinary(s, BinaryOp::LtVecF64x2); } + goto parse_error; + default: goto parse_error; + } + } + case 'm': { + switch (op[7]) { + case 'a': + if (strcmp(op, "f64x2.max") == 0) { return makeBinary(s, BinaryOp::MaxVecF64x2); } + goto parse_error; + case 'i': + if (strcmp(op, "f64x2.min") == 0) { return makeBinary(s, BinaryOp::MinVecF64x2); } + goto parse_error; + case 'u': + if (strcmp(op, "f64x2.mul") == 0) { return makeBinary(s, BinaryOp::MulVecF64x2); } + goto parse_error; + default: goto parse_error; + } + } + case 'n': { + switch (op[8]) { + case '\0': + if (strcmp(op, "f64x2.ne") == 0) { return makeBinary(s, BinaryOp::NeVecF64x2); } + goto parse_error; + case 'a': + if (strcmp(op, "f64x2.nearest") == 0) { return makeUnary(s, UnaryOp::NearestVecF64x2); } + goto parse_error; + case 'g': + if (strcmp(op, "f64x2.neg") == 0) { return makeUnary(s, UnaryOp::NegVecF64x2); } + goto parse_error; + default: goto parse_error; + } + } + case 'p': { + switch (op[8]) { + case 'a': + if (strcmp(op, "f64x2.pmax") == 0) { return makeBinary(s, BinaryOp::PMaxVecF64x2); } + goto parse_error; + case 'i': + if (strcmp(op, "f64x2.pmin") == 0) { return makeBinary(s, BinaryOp::PMinVecF64x2); } + goto parse_error; + default: goto parse_error; + } + } + case 'q': { + switch (op[9]) { + case 'a': + if (strcmp(op, "f64x2.qfma") == 0) { return makeSIMDTernary(s, SIMDTernaryOp::QFMAF64x2); } + goto parse_error; + case 's': + if (strcmp(op, "f64x2.qfms") == 0) { return makeSIMDTernary(s, SIMDTernaryOp::QFMSF64x2); } + goto parse_error; + default: goto parse_error; + } + } + case 'r': + if (strcmp(op, "f64x2.replace_lane") == 0) { return makeSIMDReplace(s, SIMDReplaceOp::ReplaceLaneVecF64x2, 2); } + goto parse_error; + case 's': { + switch (op[7]) { + case 'p': + if (strcmp(op, "f64x2.splat") == 0) { return makeUnary(s, UnaryOp::SplatVecF64x2); } + goto parse_error; + case 'q': + if (strcmp(op, "f64x2.sqrt") == 0) { return makeUnary(s, UnaryOp::SqrtVecF64x2); } + goto parse_error; + case 'u': + if (strcmp(op, "f64x2.sub") == 0) { return makeBinary(s, BinaryOp::SubVecF64x2); } + goto parse_error; + default: goto parse_error; + } + } + case 't': + if (strcmp(op, "f64x2.trunc") == 0) { return makeUnary(s, UnaryOp::TruncVecF64x2); } + goto parse_error; + default: goto parse_error; + } + } + default: goto parse_error; + } + } + default: goto parse_error; + } + } + case 'g': { + switch (op[7]) { + case 'g': + if (strcmp(op, "global.get") == 0) { return makeGlobalGet(s); } + goto parse_error; + case 's': + if (strcmp(op, "global.set") == 0) { return makeGlobalSet(s); } + goto parse_error; + default: goto parse_error; + } + } + case 'i': { + switch (op[1]) { + case '1': { + switch (op[6]) { + case 'a': { + switch (op[7]) { + case 'b': + if (strcmp(op, "i16x8.abs") == 0) { return makeUnary(s, UnaryOp::AbsVecI16x8); } + goto parse_error; + case 'd': { + switch (op[9]) { + case '\0': + if (strcmp(op, "i16x8.add") == 0) { return makeBinary(s, BinaryOp::AddVecI16x8); } + goto parse_error; + case '_': { + switch (op[19]) { + case 's': + if (strcmp(op, "i16x8.add_saturate_s") == 0) { return makeBinary(s, BinaryOp::AddSatSVecI16x8); } + goto parse_error; + case 'u': + if (strcmp(op, "i16x8.add_saturate_u") == 0) { return makeBinary(s, BinaryOp::AddSatUVecI16x8); } + goto parse_error; + default: goto parse_error; + } + } + default: goto parse_error; + } + } + case 'l': + if (strcmp(op, "i16x8.all_true") == 0) { return makeUnary(s, UnaryOp::AllTrueVecI16x8); } + goto parse_error; + case 'n': + if (strcmp(op, "i16x8.any_true") == 0) { return makeUnary(s, UnaryOp::AnyTrueVecI16x8); } + goto parse_error; + case 'v': + if (strcmp(op, "i16x8.avgr_u") == 0) { return makeBinary(s, BinaryOp::AvgrUVecI16x8); } + goto parse_error; + default: goto parse_error; + } + } + case 'b': + if (strcmp(op, "i16x8.bitmask") == 0) { return makeUnary(s, UnaryOp::BitmaskVecI16x8); } + goto parse_error; + case 'e': { + switch (op[7]) { + case 'q': + if (strcmp(op, "i16x8.eq") == 0) { return makeBinary(s, BinaryOp::EqVecI16x8); } + goto parse_error; + case 'x': { + switch (op[19]) { + case 's': + if (strcmp(op, "i16x8.extract_lane_s") == 0) { return makeSIMDExtract(s, SIMDExtractOp::ExtractLaneSVecI16x8, 8); } + goto parse_error; + case 'u': + if (strcmp(op, "i16x8.extract_lane_u") == 0) { return makeSIMDExtract(s, SIMDExtractOp::ExtractLaneUVecI16x8, 8); } + goto parse_error; + default: goto parse_error; + } + } + default: goto parse_error; + } + } + case 'g': { + switch (op[7]) { + case 'e': { + switch (op[9]) { + case 's': + if (strcmp(op, "i16x8.ge_s") == 0) { return makeBinary(s, BinaryOp::GeSVecI16x8); } + goto parse_error; + case 'u': + if (strcmp(op, "i16x8.ge_u") == 0) { return makeBinary(s, BinaryOp::GeUVecI16x8); } + goto parse_error; + default: goto parse_error; + } + } + case 't': { + switch (op[9]) { + case 's': + if (strcmp(op, "i16x8.gt_s") == 0) { return makeBinary(s, BinaryOp::GtSVecI16x8); } + goto parse_error; + case 'u': + if (strcmp(op, "i16x8.gt_u") == 0) { return makeBinary(s, BinaryOp::GtUVecI16x8); } + goto parse_error; + default: goto parse_error; + } + } + default: goto parse_error; + } + } + case 'l': { + switch (op[7]) { + case 'e': { + switch (op[9]) { + case 's': + if (strcmp(op, "i16x8.le_s") == 0) { return makeBinary(s, BinaryOp::LeSVecI16x8); } + goto parse_error; + case 'u': + if (strcmp(op, "i16x8.le_u") == 0) { return makeBinary(s, BinaryOp::LeUVecI16x8); } + goto parse_error; + default: goto parse_error; + } + } + case 'o': { + switch (op[14]) { + case 's': + if (strcmp(op, "i16x8.load8x8_s") == 0) { return makeSIMDLoad(s, SIMDLoadOp::LoadExtSVec8x8ToVecI16x8); } + goto parse_error; + case 'u': + if (strcmp(op, "i16x8.load8x8_u") == 0) { return makeSIMDLoad(s, SIMDLoadOp::LoadExtUVec8x8ToVecI16x8); } + goto parse_error; + default: goto parse_error; + } + } + case 't': { + switch (op[9]) { + case 's': + if (strcmp(op, "i16x8.lt_s") == 0) { return makeBinary(s, BinaryOp::LtSVecI16x8); } + goto parse_error; + case 'u': + if (strcmp(op, "i16x8.lt_u") == 0) { return makeBinary(s, BinaryOp::LtUVecI16x8); } + goto parse_error; + default: goto parse_error; + } + } + default: goto parse_error; + } + } + case 'm': { + switch (op[7]) { + case 'a': { + switch (op[10]) { + case 's': + if (strcmp(op, "i16x8.max_s") == 0) { return makeBinary(s, BinaryOp::MaxSVecI16x8); } + goto parse_error; + case 'u': + if (strcmp(op, "i16x8.max_u") == 0) { return makeBinary(s, BinaryOp::MaxUVecI16x8); } + goto parse_error; + default: goto parse_error; + } + } + case 'i': { + switch (op[10]) { + case 's': + if (strcmp(op, "i16x8.min_s") == 0) { return makeBinary(s, BinaryOp::MinSVecI16x8); } + goto parse_error; + case 'u': + if (strcmp(op, "i16x8.min_u") == 0) { return makeBinary(s, BinaryOp::MinUVecI16x8); } + goto parse_error; + default: goto parse_error; + } + } + case 'u': + if (strcmp(op, "i16x8.mul") == 0) { return makeBinary(s, BinaryOp::MulVecI16x8); } + goto parse_error; + default: goto parse_error; + } + } + case 'n': { + switch (op[7]) { + case 'a': { + switch (op[19]) { + case 's': + if (strcmp(op, "i16x8.narrow_i32x4_s") == 0) { return makeBinary(s, BinaryOp::NarrowSVecI32x4ToVecI16x8); } + goto parse_error; + case 'u': + if (strcmp(op, "i16x8.narrow_i32x4_u") == 0) { return makeBinary(s, BinaryOp::NarrowUVecI32x4ToVecI16x8); } + goto parse_error; + default: goto parse_error; + } + } + case 'e': { + switch (op[8]) { + case '\0': + if (strcmp(op, "i16x8.ne") == 0) { return makeBinary(s, BinaryOp::NeVecI16x8); } + goto parse_error; + case 'g': + if (strcmp(op, "i16x8.neg") == 0) { return makeUnary(s, UnaryOp::NegVecI16x8); } + goto parse_error; + default: goto parse_error; + } + } + default: goto parse_error; + } + } + case 'r': + if (strcmp(op, "i16x8.replace_lane") == 0) { return makeSIMDReplace(s, SIMDReplaceOp::ReplaceLaneVecI16x8, 8); } + goto parse_error; + case 's': { + switch (op[7]) { + case 'h': { + switch (op[8]) { + case 'l': + if (strcmp(op, "i16x8.shl") == 0) { return makeSIMDShift(s, SIMDShiftOp::ShlVecI16x8); } + goto parse_error; + case 'r': { + switch (op[10]) { + case 's': + if (strcmp(op, "i16x8.shr_s") == 0) { return makeSIMDShift(s, SIMDShiftOp::ShrSVecI16x8); } + goto parse_error; + case 'u': + if (strcmp(op, "i16x8.shr_u") == 0) { return makeSIMDShift(s, SIMDShiftOp::ShrUVecI16x8); } + goto parse_error; + default: goto parse_error; + } + } + default: goto parse_error; + } + } + case 'p': + if (strcmp(op, "i16x8.splat") == 0) { return makeUnary(s, UnaryOp::SplatVecI16x8); } + goto parse_error; + case 'u': { + switch (op[9]) { + case '\0': + if (strcmp(op, "i16x8.sub") == 0) { return makeBinary(s, BinaryOp::SubVecI16x8); } + goto parse_error; + case '_': { + switch (op[19]) { + case 's': + if (strcmp(op, "i16x8.sub_saturate_s") == 0) { return makeBinary(s, BinaryOp::SubSatSVecI16x8); } + goto parse_error; + case 'u': + if (strcmp(op, "i16x8.sub_saturate_u") == 0) { return makeBinary(s, BinaryOp::SubSatUVecI16x8); } + goto parse_error; + default: goto parse_error; + } + } + default: goto parse_error; + } + } + default: goto parse_error; + } + } + case 'w': { + switch (op[12]) { + case 'h': { + switch (op[23]) { + case 's': + if (strcmp(op, "i16x8.widen_high_i8x16_s") == 0) { return makeUnary(s, UnaryOp::WidenHighSVecI8x16ToVecI16x8); } + goto parse_error; + case 'u': + if (strcmp(op, "i16x8.widen_high_i8x16_u") == 0) { return makeUnary(s, UnaryOp::WidenHighUVecI8x16ToVecI16x8); } + goto parse_error; + default: goto parse_error; + } + } + case 'l': { + switch (op[22]) { + case 's': + if (strcmp(op, "i16x8.widen_low_i8x16_s") == 0) { return makeUnary(s, UnaryOp::WidenLowSVecI8x16ToVecI16x8); } + goto parse_error; + case 'u': + if (strcmp(op, "i16x8.widen_low_i8x16_u") == 0) { return makeUnary(s, UnaryOp::WidenLowUVecI8x16ToVecI16x8); } + goto parse_error; + default: goto parse_error; + } + } + default: goto parse_error; + } + } + default: goto parse_error; + } + } + case '3': { + switch (op[2]) { + case '1': { + switch (op[4]) { + case 'g': { + switch (op[8]) { + case 's': + if (strcmp(op, "i31.get_s") == 0) { return makeI31Get(s, true); } + goto parse_error; + case 'u': + if (strcmp(op, "i31.get_u") == 0) { return makeI31Get(s, false); } + goto parse_error; + default: goto parse_error; + } + } + case 'n': + if (strcmp(op, "i31.new") == 0) { return makeI31New(s); } + goto parse_error; + default: goto parse_error; + } + } + case '2': { + switch (op[3]) { + case '.': { + switch (op[4]) { + case 'a': { + switch (op[5]) { + case 'd': + if (strcmp(op, "i32.add") == 0) { return makeBinary(s, BinaryOp::AddInt32); } + goto parse_error; + case 'n': + if (strcmp(op, "i32.and") == 0) { return makeBinary(s, BinaryOp::AndInt32); } + goto parse_error; + case 't': { + switch (op[11]) { + case 'l': { + switch (op[15]) { + case '\0': + if (strcmp(op, "i32.atomic.load") == 0) { return makeLoad(s, Type::i32, /*isAtomic=*/true); } + goto parse_error; + case '1': + if (strcmp(op, "i32.atomic.load16_u") == 0) { return makeLoad(s, Type::i32, /*isAtomic=*/true); } + goto parse_error; + case '8': + if (strcmp(op, "i32.atomic.load8_u") == 0) { return makeLoad(s, Type::i32, /*isAtomic=*/true); } + goto parse_error; + default: goto parse_error; + } + } + case 'r': { + switch (op[14]) { + case '.': { + switch (op[15]) { + case 'a': { + switch (op[16]) { + case 'd': + if (strcmp(op, "i32.atomic.rmw.add") == 0) { return makeAtomicRMWOrCmpxchg(s, Type::i32); } + goto parse_error; + case 'n': + if (strcmp(op, "i32.atomic.rmw.and") == 0) { return makeAtomicRMWOrCmpxchg(s, Type::i32); } + goto parse_error; + default: goto parse_error; + } + } + case 'c': + if (strcmp(op, "i32.atomic.rmw.cmpxchg") == 0) { return makeAtomicRMWOrCmpxchg(s, Type::i32); } + goto parse_error; + case 'o': + if (strcmp(op, "i32.atomic.rmw.or") == 0) { return makeAtomicRMWOrCmpxchg(s, Type::i32); } + goto parse_error; + case 's': + if (strcmp(op, "i32.atomic.rmw.sub") == 0) { return makeAtomicRMWOrCmpxchg(s, Type::i32); } + goto parse_error; + case 'x': { + switch (op[16]) { + case 'c': + if (strcmp(op, "i32.atomic.rmw.xchg") == 0) { return makeAtomicRMWOrCmpxchg(s, Type::i32); } + goto parse_error; + case 'o': + if (strcmp(op, "i32.atomic.rmw.xor") == 0) { return makeAtomicRMWOrCmpxchg(s, Type::i32); } + goto parse_error; + default: goto parse_error; + } + } + default: goto parse_error; + } + } + case '1': { + switch (op[17]) { + case 'a': { + switch (op[18]) { + case 'd': + if (strcmp(op, "i32.atomic.rmw16.add_u") == 0) { return makeAtomicRMWOrCmpxchg(s, Type::i32); } + goto parse_error; + case 'n': + if (strcmp(op, "i32.atomic.rmw16.and_u") == 0) { return makeAtomicRMWOrCmpxchg(s, Type::i32); } + goto parse_error; + default: goto parse_error; + } + } + case 'c': + if (strcmp(op, "i32.atomic.rmw16.cmpxchg_u") == 0) { return makeAtomicRMWOrCmpxchg(s, Type::i32); } + goto parse_error; + case 'o': + if (strcmp(op, "i32.atomic.rmw16.or_u") == 0) { return makeAtomicRMWOrCmpxchg(s, Type::i32); } + goto parse_error; + case 's': + if (strcmp(op, "i32.atomic.rmw16.sub_u") == 0) { return makeAtomicRMWOrCmpxchg(s, Type::i32); } + goto parse_error; + case 'x': { + switch (op[18]) { + case 'c': + if (strcmp(op, "i32.atomic.rmw16.xchg_u") == 0) { return makeAtomicRMWOrCmpxchg(s, Type::i32); } + goto parse_error; + case 'o': + if (strcmp(op, "i32.atomic.rmw16.xor_u") == 0) { return makeAtomicRMWOrCmpxchg(s, Type::i32); } + goto parse_error; + default: goto parse_error; + } + } + default: goto parse_error; + } + } + case '8': { + switch (op[16]) { + case 'a': { + switch (op[17]) { + case 'd': + if (strcmp(op, "i32.atomic.rmw8.add_u") == 0) { return makeAtomicRMWOrCmpxchg(s, Type::i32); } + goto parse_error; + case 'n': + if (strcmp(op, "i32.atomic.rmw8.and_u") == 0) { return makeAtomicRMWOrCmpxchg(s, Type::i32); } + goto parse_error; + default: goto parse_error; + } + } + case 'c': + if (strcmp(op, "i32.atomic.rmw8.cmpxchg_u") == 0) { return makeAtomicRMWOrCmpxchg(s, Type::i32); } + goto parse_error; + case 'o': + if (strcmp(op, "i32.atomic.rmw8.or_u") == 0) { return makeAtomicRMWOrCmpxchg(s, Type::i32); } + goto parse_error; + case 's': + if (strcmp(op, "i32.atomic.rmw8.sub_u") == 0) { return makeAtomicRMWOrCmpxchg(s, Type::i32); } + goto parse_error; + case 'x': { + switch (op[17]) { + case 'c': + if (strcmp(op, "i32.atomic.rmw8.xchg_u") == 0) { return makeAtomicRMWOrCmpxchg(s, Type::i32); } + goto parse_error; + case 'o': + if (strcmp(op, "i32.atomic.rmw8.xor_u") == 0) { return makeAtomicRMWOrCmpxchg(s, Type::i32); } + goto parse_error; + default: goto parse_error; + } + } + default: goto parse_error; + } + } + default: goto parse_error; + } + } + case 's': { + switch (op[16]) { + case '\0': + if (strcmp(op, "i32.atomic.store") == 0) { return makeStore(s, Type::i32, /*isAtomic=*/true); } + goto parse_error; + case '1': + if (strcmp(op, "i32.atomic.store16") == 0) { return makeStore(s, Type::i32, /*isAtomic=*/true); } + goto parse_error; + case '8': + if (strcmp(op, "i32.atomic.store8") == 0) { return makeStore(s, Type::i32, /*isAtomic=*/true); } + goto parse_error; + default: goto parse_error; + } + } + case 'w': + if (strcmp(op, "i32.atomic.wait") == 0) { return makeAtomicWait(s, Type::i32); } + goto parse_error; + default: goto parse_error; + } + } + default: goto parse_error; + } + } + case 'c': { + switch (op[5]) { + case 'l': + if (strcmp(op, "i32.clz") == 0) { return makeUnary(s, UnaryOp::ClzInt32); } + goto parse_error; + case 'o': + if (strcmp(op, "i32.const") == 0) { return makeConst(s, Type::i32); } + goto parse_error; + case 't': + if (strcmp(op, "i32.ctz") == 0) { return makeUnary(s, UnaryOp::CtzInt32); } + goto parse_error; + default: goto parse_error; + } + } + case 'd': { + switch (op[8]) { + case 's': + if (strcmp(op, "i32.div_s") == 0) { return makeBinary(s, BinaryOp::DivSInt32); } + goto parse_error; + case 'u': + if (strcmp(op, "i32.div_u") == 0) { return makeBinary(s, BinaryOp::DivUInt32); } + goto parse_error; + default: goto parse_error; + } + } + case 'e': { + switch (op[5]) { + case 'q': { + switch (op[6]) { + case '\0': + if (strcmp(op, "i32.eq") == 0) { return makeBinary(s, BinaryOp::EqInt32); } + goto parse_error; + case 'z': + if (strcmp(op, "i32.eqz") == 0) { return makeUnary(s, UnaryOp::EqZInt32); } + goto parse_error; + default: goto parse_error; + } + } + case 'x': { + switch (op[10]) { + case '1': + if (strcmp(op, "i32.extend16_s") == 0) { return makeUnary(s, UnaryOp::ExtendS16Int32); } + goto parse_error; + case '8': + if (strcmp(op, "i32.extend8_s") == 0) { return makeUnary(s, UnaryOp::ExtendS8Int32); } + goto parse_error; + default: goto parse_error; + } + } + default: goto parse_error; + } + } + case 'g': { + switch (op[5]) { + case 'e': { + switch (op[7]) { + case 's': + if (strcmp(op, "i32.ge_s") == 0) { return makeBinary(s, BinaryOp::GeSInt32); } + goto parse_error; + case 'u': + if (strcmp(op, "i32.ge_u") == 0) { return makeBinary(s, BinaryOp::GeUInt32); } + goto parse_error; + default: goto parse_error; + } + } + case 't': { + switch (op[7]) { + case 's': + if (strcmp(op, "i32.gt_s") == 0) { return makeBinary(s, BinaryOp::GtSInt32); } + goto parse_error; + case 'u': + if (strcmp(op, "i32.gt_u") == 0) { return makeBinary(s, BinaryOp::GtUInt32); } + goto parse_error; + default: goto parse_error; + } + } + default: goto parse_error; + } + } + case 'l': { + switch (op[5]) { + case 'e': { + switch (op[7]) { + case 's': + if (strcmp(op, "i32.le_s") == 0) { return makeBinary(s, BinaryOp::LeSInt32); } + goto parse_error; + case 'u': + if (strcmp(op, "i32.le_u") == 0) { return makeBinary(s, BinaryOp::LeUInt32); } + goto parse_error; + default: goto parse_error; + } + } + case 'o': { + switch (op[8]) { + case '\0': + if (strcmp(op, "i32.load") == 0) { return makeLoad(s, Type::i32, /*isAtomic=*/false); } + goto parse_error; + case '1': { + switch (op[11]) { + case 's': + if (strcmp(op, "i32.load16_s") == 0) { return makeLoad(s, Type::i32, /*isAtomic=*/false); } + goto parse_error; + case 'u': + if (strcmp(op, "i32.load16_u") == 0) { return makeLoad(s, Type::i32, /*isAtomic=*/false); } + goto parse_error; + default: goto parse_error; + } + } + case '8': { + switch (op[10]) { + case 's': + if (strcmp(op, "i32.load8_s") == 0) { return makeLoad(s, Type::i32, /*isAtomic=*/false); } + goto parse_error; + case 'u': + if (strcmp(op, "i32.load8_u") == 0) { return makeLoad(s, Type::i32, /*isAtomic=*/false); } + goto parse_error; + default: goto parse_error; + } + } + default: goto parse_error; + } + } + case 't': { + switch (op[7]) { + case 's': + if (strcmp(op, "i32.lt_s") == 0) { return makeBinary(s, BinaryOp::LtSInt32); } + goto parse_error; + case 'u': + if (strcmp(op, "i32.lt_u") == 0) { return makeBinary(s, BinaryOp::LtUInt32); } + goto parse_error; + default: goto parse_error; + } + } + default: goto parse_error; + } + } + case 'm': + if (strcmp(op, "i32.mul") == 0) { return makeBinary(s, BinaryOp::MulInt32); } + goto parse_error; + case 'n': + if (strcmp(op, "i32.ne") == 0) { return makeBinary(s, BinaryOp::NeInt32); } + goto parse_error; + case 'o': + if (strcmp(op, "i32.or") == 0) { return makeBinary(s, BinaryOp::OrInt32); } + goto parse_error; + case 'p': + if (strcmp(op, "i32.popcnt") == 0) { return makeUnary(s, UnaryOp::PopcntInt32); } + goto parse_error; + case 'r': { + switch (op[5]) { + case 'e': { + switch (op[6]) { + case 'i': + if (strcmp(op, "i32.reinterpret_f32") == 0) { return makeUnary(s, UnaryOp::ReinterpretFloat32); } + goto parse_error; + case 'm': { + switch (op[8]) { + case 's': + if (strcmp(op, "i32.rem_s") == 0) { return makeBinary(s, BinaryOp::RemSInt32); } + goto parse_error; + case 'u': + if (strcmp(op, "i32.rem_u") == 0) { return makeBinary(s, BinaryOp::RemUInt32); } + goto parse_error; + default: goto parse_error; + } + } + default: goto parse_error; + } + } + case 'o': { + switch (op[7]) { + case 'l': + if (strcmp(op, "i32.rotl") == 0) { return makeBinary(s, BinaryOp::RotLInt32); } + goto parse_error; + case 'r': + if (strcmp(op, "i32.rotr") == 0) { return makeBinary(s, BinaryOp::RotRInt32); } + goto parse_error; + default: goto parse_error; + } + } + default: goto parse_error; + } + } + case 's': { + switch (op[5]) { + case 'h': { + switch (op[6]) { + case 'l': + if (strcmp(op, "i32.shl") == 0) { return makeBinary(s, BinaryOp::ShlInt32); } + goto parse_error; + case 'r': { + switch (op[8]) { + case 's': + if (strcmp(op, "i32.shr_s") == 0) { return makeBinary(s, BinaryOp::ShrSInt32); } + goto parse_error; + case 'u': + if (strcmp(op, "i32.shr_u") == 0) { return makeBinary(s, BinaryOp::ShrUInt32); } + goto parse_error; + default: goto parse_error; + } + } + default: goto parse_error; + } + } + case 't': { + switch (op[9]) { + case '\0': + if (strcmp(op, "i32.store") == 0) { return makeStore(s, Type::i32, /*isAtomic=*/false); } + goto parse_error; + case '1': + if (strcmp(op, "i32.store16") == 0) { return makeStore(s, Type::i32, /*isAtomic=*/false); } + goto parse_error; + case '8': + if (strcmp(op, "i32.store8") == 0) { return makeStore(s, Type::i32, /*isAtomic=*/false); } + goto parse_error; + default: goto parse_error; + } + } + case 'u': + if (strcmp(op, "i32.sub") == 0) { return makeBinary(s, BinaryOp::SubInt32); } + goto parse_error; + default: goto parse_error; + } + } + case 't': { + switch (op[10]) { + case 'f': { + switch (op[11]) { + case '3': { + switch (op[14]) { + case 's': + if (strcmp(op, "i32.trunc_f32_s") == 0) { return makeUnary(s, UnaryOp::TruncSFloat32ToInt32); } + goto parse_error; + case 'u': + if (strcmp(op, "i32.trunc_f32_u") == 0) { return makeUnary(s, UnaryOp::TruncUFloat32ToInt32); } + goto parse_error; + default: goto parse_error; + } + } + case '6': { + switch (op[14]) { + case 's': + if (strcmp(op, "i32.trunc_f64_s") == 0) { return makeUnary(s, UnaryOp::TruncSFloat64ToInt32); } + goto parse_error; + case 'u': + if (strcmp(op, "i32.trunc_f64_u") == 0) { return makeUnary(s, UnaryOp::TruncUFloat64ToInt32); } + goto parse_error; + default: goto parse_error; + } + } + default: goto parse_error; + } + } + case 's': { + switch (op[15]) { + case '3': { + switch (op[18]) { + case 's': + if (strcmp(op, "i32.trunc_sat_f32_s") == 0) { return makeUnary(s, UnaryOp::TruncSatSFloat32ToInt32); } + goto parse_error; + case 'u': + if (strcmp(op, "i32.trunc_sat_f32_u") == 0) { return makeUnary(s, UnaryOp::TruncSatUFloat32ToInt32); } + goto parse_error; + default: goto parse_error; + } + } + case '6': { + switch (op[18]) { + case 's': + if (strcmp(op, "i32.trunc_sat_f64_s") == 0) { return makeUnary(s, UnaryOp::TruncSatSFloat64ToInt32); } + goto parse_error; + case 'u': + if (strcmp(op, "i32.trunc_sat_f64_u") == 0) { return makeUnary(s, UnaryOp::TruncSatUFloat64ToInt32); } + goto parse_error; + default: goto parse_error; + } + } + default: goto parse_error; + } + } + default: goto parse_error; + } + } + case 'w': + if (strcmp(op, "i32.wrap_i64") == 0) { return makeUnary(s, UnaryOp::WrapInt64); } + goto parse_error; + case 'x': + if (strcmp(op, "i32.xor") == 0) { return makeBinary(s, BinaryOp::XorInt32); } + goto parse_error; + default: goto parse_error; + } + } + case 'x': { + switch (op[6]) { + case 'a': { + switch (op[7]) { + case 'b': + if (strcmp(op, "i32x4.abs") == 0) { return makeUnary(s, UnaryOp::AbsVecI32x4); } + goto parse_error; + case 'd': + if (strcmp(op, "i32x4.add") == 0) { return makeBinary(s, BinaryOp::AddVecI32x4); } + goto parse_error; + case 'l': + if (strcmp(op, "i32x4.all_true") == 0) { return makeUnary(s, UnaryOp::AllTrueVecI32x4); } + goto parse_error; + case 'n': + if (strcmp(op, "i32x4.any_true") == 0) { return makeUnary(s, UnaryOp::AnyTrueVecI32x4); } + goto parse_error; + default: goto parse_error; + } + } + case 'b': + if (strcmp(op, "i32x4.bitmask") == 0) { return makeUnary(s, UnaryOp::BitmaskVecI32x4); } + goto parse_error; + case 'd': + if (strcmp(op, "i32x4.dot_i16x8_s") == 0) { return makeBinary(s, BinaryOp::DotSVecI16x8ToVecI32x4); } + goto parse_error; + case 'e': { + switch (op[7]) { + case 'q': + if (strcmp(op, "i32x4.eq") == 0) { return makeBinary(s, BinaryOp::EqVecI32x4); } + goto parse_error; + case 'x': + if (strcmp(op, "i32x4.extract_lane") == 0) { return makeSIMDExtract(s, SIMDExtractOp::ExtractLaneVecI32x4, 4); } + goto parse_error; + default: goto parse_error; + } + } + case 'g': { + switch (op[7]) { + case 'e': { + switch (op[9]) { + case 's': + if (strcmp(op, "i32x4.ge_s") == 0) { return makeBinary(s, BinaryOp::GeSVecI32x4); } + goto parse_error; + case 'u': + if (strcmp(op, "i32x4.ge_u") == 0) { return makeBinary(s, BinaryOp::GeUVecI32x4); } + goto parse_error; + default: goto parse_error; + } + } + case 't': { + switch (op[9]) { + case 's': + if (strcmp(op, "i32x4.gt_s") == 0) { return makeBinary(s, BinaryOp::GtSVecI32x4); } + goto parse_error; + case 'u': + if (strcmp(op, "i32x4.gt_u") == 0) { return makeBinary(s, BinaryOp::GtUVecI32x4); } + goto parse_error; + default: goto parse_error; + } + } + default: goto parse_error; + } + } + case 'l': { + switch (op[7]) { + case 'e': { + switch (op[9]) { + case 's': + if (strcmp(op, "i32x4.le_s") == 0) { return makeBinary(s, BinaryOp::LeSVecI32x4); } + goto parse_error; + case 'u': + if (strcmp(op, "i32x4.le_u") == 0) { return makeBinary(s, BinaryOp::LeUVecI32x4); } + goto parse_error; + default: goto parse_error; + } + } + case 'o': { + switch (op[15]) { + case 's': + if (strcmp(op, "i32x4.load16x4_s") == 0) { return makeSIMDLoad(s, SIMDLoadOp::LoadExtSVec16x4ToVecI32x4); } + goto parse_error; + case 'u': + if (strcmp(op, "i32x4.load16x4_u") == 0) { return makeSIMDLoad(s, SIMDLoadOp::LoadExtUVec16x4ToVecI32x4); } + goto parse_error; + default: goto parse_error; + } + } + case 't': { + switch (op[9]) { + case 's': + if (strcmp(op, "i32x4.lt_s") == 0) { return makeBinary(s, BinaryOp::LtSVecI32x4); } + goto parse_error; + case 'u': + if (strcmp(op, "i32x4.lt_u") == 0) { return makeBinary(s, BinaryOp::LtUVecI32x4); } + goto parse_error; + default: goto parse_error; + } + } + default: goto parse_error; + } + } + case 'm': { + switch (op[7]) { + case 'a': { + switch (op[10]) { + case 's': + if (strcmp(op, "i32x4.max_s") == 0) { return makeBinary(s, BinaryOp::MaxSVecI32x4); } + goto parse_error; + case 'u': + if (strcmp(op, "i32x4.max_u") == 0) { return makeBinary(s, BinaryOp::MaxUVecI32x4); } + goto parse_error; + default: goto parse_error; + } + } + case 'i': { + switch (op[10]) { + case 's': + if (strcmp(op, "i32x4.min_s") == 0) { return makeBinary(s, BinaryOp::MinSVecI32x4); } + goto parse_error; + case 'u': + if (strcmp(op, "i32x4.min_u") == 0) { return makeBinary(s, BinaryOp::MinUVecI32x4); } + goto parse_error; + default: goto parse_error; + } + } + case 'u': + if (strcmp(op, "i32x4.mul") == 0) { return makeBinary(s, BinaryOp::MulVecI32x4); } + goto parse_error; + default: goto parse_error; + } + } + case 'n': { + switch (op[8]) { + case '\0': + if (strcmp(op, "i32x4.ne") == 0) { return makeBinary(s, BinaryOp::NeVecI32x4); } + goto parse_error; + case 'g': + if (strcmp(op, "i32x4.neg") == 0) { return makeUnary(s, UnaryOp::NegVecI32x4); } + goto parse_error; + default: goto parse_error; + } + } + case 'r': + if (strcmp(op, "i32x4.replace_lane") == 0) { return makeSIMDReplace(s, SIMDReplaceOp::ReplaceLaneVecI32x4, 4); } + goto parse_error; + case 's': { + switch (op[7]) { + case 'h': { + switch (op[8]) { + case 'l': + if (strcmp(op, "i32x4.shl") == 0) { return makeSIMDShift(s, SIMDShiftOp::ShlVecI32x4); } + goto parse_error; + case 'r': { + switch (op[10]) { + case 's': + if (strcmp(op, "i32x4.shr_s") == 0) { return makeSIMDShift(s, SIMDShiftOp::ShrSVecI32x4); } + goto parse_error; + case 'u': + if (strcmp(op, "i32x4.shr_u") == 0) { return makeSIMDShift(s, SIMDShiftOp::ShrUVecI32x4); } + goto parse_error; + default: goto parse_error; + } + } + default: goto parse_error; + } + } + case 'p': + if (strcmp(op, "i32x4.splat") == 0) { return makeUnary(s, UnaryOp::SplatVecI32x4); } + goto parse_error; + case 'u': + if (strcmp(op, "i32x4.sub") == 0) { return makeBinary(s, BinaryOp::SubVecI32x4); } + goto parse_error; + default: goto parse_error; + } + } + case 't': { + switch (op[22]) { + case 's': + if (strcmp(op, "i32x4.trunc_sat_f32x4_s") == 0) { return makeUnary(s, UnaryOp::TruncSatSVecF32x4ToVecI32x4); } + goto parse_error; + case 'u': + if (strcmp(op, "i32x4.trunc_sat_f32x4_u") == 0) { return makeUnary(s, UnaryOp::TruncSatUVecF32x4ToVecI32x4); } + goto parse_error; + default: goto parse_error; + } + } + case 'w': { + switch (op[12]) { + case 'h': { + switch (op[23]) { + case 's': + if (strcmp(op, "i32x4.widen_high_i16x8_s") == 0) { return makeUnary(s, UnaryOp::WidenHighSVecI16x8ToVecI32x4); } + goto parse_error; + case 'u': + if (strcmp(op, "i32x4.widen_high_i16x8_u") == 0) { return makeUnary(s, UnaryOp::WidenHighUVecI16x8ToVecI32x4); } + goto parse_error; + default: goto parse_error; + } + } + case 'l': { + switch (op[22]) { + case 's': + if (strcmp(op, "i32x4.widen_low_i16x8_s") == 0) { return makeUnary(s, UnaryOp::WidenLowSVecI16x8ToVecI32x4); } + goto parse_error; + case 'u': + if (strcmp(op, "i32x4.widen_low_i16x8_u") == 0) { return makeUnary(s, UnaryOp::WidenLowUVecI16x8ToVecI32x4); } + goto parse_error; + default: goto parse_error; + } + } + default: goto parse_error; + } + } + default: goto parse_error; + } + } + default: goto parse_error; + } + } + default: goto parse_error; + } + } + case '6': { + switch (op[3]) { + case '.': { + switch (op[4]) { + case 'a': { + switch (op[5]) { + case 'd': + if (strcmp(op, "i64.add") == 0) { return makeBinary(s, BinaryOp::AddInt64); } + goto parse_error; + case 'n': + if (strcmp(op, "i64.and") == 0) { return makeBinary(s, BinaryOp::AndInt64); } + goto parse_error; + case 't': { + switch (op[11]) { + case 'l': { + switch (op[15]) { + case '\0': + if (strcmp(op, "i64.atomic.load") == 0) { return makeLoad(s, Type::i64, /*isAtomic=*/true); } + goto parse_error; + case '1': + if (strcmp(op, "i64.atomic.load16_u") == 0) { return makeLoad(s, Type::i64, /*isAtomic=*/true); } + goto parse_error; + case '3': + if (strcmp(op, "i64.atomic.load32_u") == 0) { return makeLoad(s, Type::i64, /*isAtomic=*/true); } + goto parse_error; + case '8': + if (strcmp(op, "i64.atomic.load8_u") == 0) { return makeLoad(s, Type::i64, /*isAtomic=*/true); } + goto parse_error; + default: goto parse_error; + } + } + case 'r': { + switch (op[14]) { + case '.': { + switch (op[15]) { + case 'a': { + switch (op[16]) { + case 'd': + if (strcmp(op, "i64.atomic.rmw.add") == 0) { return makeAtomicRMWOrCmpxchg(s, Type::i64); } + goto parse_error; + case 'n': + if (strcmp(op, "i64.atomic.rmw.and") == 0) { return makeAtomicRMWOrCmpxchg(s, Type::i64); } + goto parse_error; + default: goto parse_error; + } + } + case 'c': + if (strcmp(op, "i64.atomic.rmw.cmpxchg") == 0) { return makeAtomicRMWOrCmpxchg(s, Type::i64); } + goto parse_error; + case 'o': + if (strcmp(op, "i64.atomic.rmw.or") == 0) { return makeAtomicRMWOrCmpxchg(s, Type::i64); } + goto parse_error; + case 's': + if (strcmp(op, "i64.atomic.rmw.sub") == 0) { return makeAtomicRMWOrCmpxchg(s, Type::i64); } + goto parse_error; + case 'x': { + switch (op[16]) { + case 'c': + if (strcmp(op, "i64.atomic.rmw.xchg") == 0) { return makeAtomicRMWOrCmpxchg(s, Type::i64); } + goto parse_error; + case 'o': + if (strcmp(op, "i64.atomic.rmw.xor") == 0) { return makeAtomicRMWOrCmpxchg(s, Type::i64); } + goto parse_error; + default: goto parse_error; + } + } + default: goto parse_error; + } + } + case '1': { + switch (op[17]) { + case 'a': { + switch (op[18]) { + case 'd': + if (strcmp(op, "i64.atomic.rmw16.add_u") == 0) { return makeAtomicRMWOrCmpxchg(s, Type::i64); } + goto parse_error; + case 'n': + if (strcmp(op, "i64.atomic.rmw16.and_u") == 0) { return makeAtomicRMWOrCmpxchg(s, Type::i64); } + goto parse_error; + default: goto parse_error; + } + } + case 'c': + if (strcmp(op, "i64.atomic.rmw16.cmpxchg_u") == 0) { return makeAtomicRMWOrCmpxchg(s, Type::i64); } + goto parse_error; + case 'o': + if (strcmp(op, "i64.atomic.rmw16.or_u") == 0) { return makeAtomicRMWOrCmpxchg(s, Type::i64); } + goto parse_error; + case 's': + if (strcmp(op, "i64.atomic.rmw16.sub_u") == 0) { return makeAtomicRMWOrCmpxchg(s, Type::i64); } + goto parse_error; + case 'x': { + switch (op[18]) { + case 'c': + if (strcmp(op, "i64.atomic.rmw16.xchg_u") == 0) { return makeAtomicRMWOrCmpxchg(s, Type::i64); } + goto parse_error; + case 'o': + if (strcmp(op, "i64.atomic.rmw16.xor_u") == 0) { return makeAtomicRMWOrCmpxchg(s, Type::i64); } + goto parse_error; + default: goto parse_error; + } + } + default: goto parse_error; + } + } + case '3': { + switch (op[17]) { + case 'a': { + switch (op[18]) { + case 'd': + if (strcmp(op, "i64.atomic.rmw32.add_u") == 0) { return makeAtomicRMWOrCmpxchg(s, Type::i64); } + goto parse_error; + case 'n': + if (strcmp(op, "i64.atomic.rmw32.and_u") == 0) { return makeAtomicRMWOrCmpxchg(s, Type::i64); } + goto parse_error; + default: goto parse_error; + } + } + case 'c': + if (strcmp(op, "i64.atomic.rmw32.cmpxchg_u") == 0) { return makeAtomicRMWOrCmpxchg(s, Type::i64); } + goto parse_error; + case 'o': + if (strcmp(op, "i64.atomic.rmw32.or_u") == 0) { return makeAtomicRMWOrCmpxchg(s, Type::i64); } + goto parse_error; + case 's': + if (strcmp(op, "i64.atomic.rmw32.sub_u") == 0) { return makeAtomicRMWOrCmpxchg(s, Type::i64); } + goto parse_error; + case 'x': { + switch (op[18]) { + case 'c': + if (strcmp(op, "i64.atomic.rmw32.xchg_u") == 0) { return makeAtomicRMWOrCmpxchg(s, Type::i64); } + goto parse_error; + case 'o': + if (strcmp(op, "i64.atomic.rmw32.xor_u") == 0) { return makeAtomicRMWOrCmpxchg(s, Type::i64); } + goto parse_error; + default: goto parse_error; + } + } + default: goto parse_error; + } + } + case '8': { + switch (op[16]) { + case 'a': { + switch (op[17]) { + case 'd': + if (strcmp(op, "i64.atomic.rmw8.add_u") == 0) { return makeAtomicRMWOrCmpxchg(s, Type::i64); } + goto parse_error; + case 'n': + if (strcmp(op, "i64.atomic.rmw8.and_u") == 0) { return makeAtomicRMWOrCmpxchg(s, Type::i64); } + goto parse_error; + default: goto parse_error; + } + } + case 'c': + if (strcmp(op, "i64.atomic.rmw8.cmpxchg_u") == 0) { return makeAtomicRMWOrCmpxchg(s, Type::i64); } + goto parse_error; + case 'o': + if (strcmp(op, "i64.atomic.rmw8.or_u") == 0) { return makeAtomicRMWOrCmpxchg(s, Type::i64); } + goto parse_error; + case 's': + if (strcmp(op, "i64.atomic.rmw8.sub_u") == 0) { return makeAtomicRMWOrCmpxchg(s, Type::i64); } + goto parse_error; + case 'x': { + switch (op[17]) { + case 'c': + if (strcmp(op, "i64.atomic.rmw8.xchg_u") == 0) { return makeAtomicRMWOrCmpxchg(s, Type::i64); } + goto parse_error; + case 'o': + if (strcmp(op, "i64.atomic.rmw8.xor_u") == 0) { return makeAtomicRMWOrCmpxchg(s, Type::i64); } + goto parse_error; + default: goto parse_error; + } + } + default: goto parse_error; + } + } + default: goto parse_error; + } + } + case 's': { + switch (op[16]) { + case '\0': + if (strcmp(op, "i64.atomic.store") == 0) { return makeStore(s, Type::i64, /*isAtomic=*/true); } + goto parse_error; + case '1': + if (strcmp(op, "i64.atomic.store16") == 0) { return makeStore(s, Type::i64, /*isAtomic=*/true); } + goto parse_error; + case '3': + if (strcmp(op, "i64.atomic.store32") == 0) { return makeStore(s, Type::i64, /*isAtomic=*/true); } + goto parse_error; + case '8': + if (strcmp(op, "i64.atomic.store8") == 0) { return makeStore(s, Type::i64, /*isAtomic=*/true); } + goto parse_error; + default: goto parse_error; + } + } + case 'w': + if (strcmp(op, "i64.atomic.wait") == 0) { return makeAtomicWait(s, Type::i64); } + goto parse_error; + default: goto parse_error; + } + } + default: goto parse_error; + } + } + case 'c': { + switch (op[5]) { + case 'l': + if (strcmp(op, "i64.clz") == 0) { return makeUnary(s, UnaryOp::ClzInt64); } + goto parse_error; + case 'o': + if (strcmp(op, "i64.const") == 0) { return makeConst(s, Type::i64); } + goto parse_error; + case 't': + if (strcmp(op, "i64.ctz") == 0) { return makeUnary(s, UnaryOp::CtzInt64); } + goto parse_error; + default: goto parse_error; + } + } + case 'd': { + switch (op[8]) { + case 's': + if (strcmp(op, "i64.div_s") == 0) { return makeBinary(s, BinaryOp::DivSInt64); } + goto parse_error; + case 'u': + if (strcmp(op, "i64.div_u") == 0) { return makeBinary(s, BinaryOp::DivUInt64); } + goto parse_error; + default: goto parse_error; + } + } + case 'e': { + switch (op[5]) { + case 'q': { + switch (op[6]) { + case '\0': + if (strcmp(op, "i64.eq") == 0) { return makeBinary(s, BinaryOp::EqInt64); } + goto parse_error; + case 'z': + if (strcmp(op, "i64.eqz") == 0) { return makeUnary(s, UnaryOp::EqZInt64); } + goto parse_error; + default: goto parse_error; + } + } + case 'x': { + switch (op[10]) { + case '1': + if (strcmp(op, "i64.extend16_s") == 0) { return makeUnary(s, UnaryOp::ExtendS16Int64); } + goto parse_error; + case '3': + if (strcmp(op, "i64.extend32_s") == 0) { return makeUnary(s, UnaryOp::ExtendS32Int64); } + goto parse_error; + case '8': + if (strcmp(op, "i64.extend8_s") == 0) { return makeUnary(s, UnaryOp::ExtendS8Int64); } + goto parse_error; + case '_': { + switch (op[15]) { + case 's': + if (strcmp(op, "i64.extend_i32_s") == 0) { return makeUnary(s, UnaryOp::ExtendSInt32); } + goto parse_error; + case 'u': + if (strcmp(op, "i64.extend_i32_u") == 0) { return makeUnary(s, UnaryOp::ExtendUInt32); } + goto parse_error; + default: goto parse_error; + } + } + default: goto parse_error; + } + } + default: goto parse_error; + } + } + case 'g': { + switch (op[5]) { + case 'e': { + switch (op[7]) { + case 's': + if (strcmp(op, "i64.ge_s") == 0) { return makeBinary(s, BinaryOp::GeSInt64); } + goto parse_error; + case 'u': + if (strcmp(op, "i64.ge_u") == 0) { return makeBinary(s, BinaryOp::GeUInt64); } + goto parse_error; + default: goto parse_error; + } + } + case 't': { + switch (op[7]) { + case 's': + if (strcmp(op, "i64.gt_s") == 0) { return makeBinary(s, BinaryOp::GtSInt64); } + goto parse_error; + case 'u': + if (strcmp(op, "i64.gt_u") == 0) { return makeBinary(s, BinaryOp::GtUInt64); } + goto parse_error; + default: goto parse_error; + } + } + default: goto parse_error; + } + } + case 'l': { + switch (op[5]) { + case 'e': { + switch (op[7]) { + case 's': + if (strcmp(op, "i64.le_s") == 0) { return makeBinary(s, BinaryOp::LeSInt64); } + goto parse_error; + case 'u': + if (strcmp(op, "i64.le_u") == 0) { return makeBinary(s, BinaryOp::LeUInt64); } + goto parse_error; + default: goto parse_error; + } + } + case 'o': { + switch (op[8]) { + case '\0': + if (strcmp(op, "i64.load") == 0) { return makeLoad(s, Type::i64, /*isAtomic=*/false); } + goto parse_error; + case '1': { + switch (op[11]) { + case 's': + if (strcmp(op, "i64.load16_s") == 0) { return makeLoad(s, Type::i64, /*isAtomic=*/false); } + goto parse_error; + case 'u': + if (strcmp(op, "i64.load16_u") == 0) { return makeLoad(s, Type::i64, /*isAtomic=*/false); } + goto parse_error; + default: goto parse_error; + } + } + case '3': { + switch (op[11]) { + case 's': + if (strcmp(op, "i64.load32_s") == 0) { return makeLoad(s, Type::i64, /*isAtomic=*/false); } + goto parse_error; + case 'u': + if (strcmp(op, "i64.load32_u") == 0) { return makeLoad(s, Type::i64, /*isAtomic=*/false); } + goto parse_error; + default: goto parse_error; + } + } + case '8': { + switch (op[10]) { + case 's': + if (strcmp(op, "i64.load8_s") == 0) { return makeLoad(s, Type::i64, /*isAtomic=*/false); } + goto parse_error; + case 'u': + if (strcmp(op, "i64.load8_u") == 0) { return makeLoad(s, Type::i64, /*isAtomic=*/false); } + goto parse_error; + default: goto parse_error; + } + } + default: goto parse_error; + } + } + case 't': { + switch (op[7]) { + case 's': + if (strcmp(op, "i64.lt_s") == 0) { return makeBinary(s, BinaryOp::LtSInt64); } + goto parse_error; + case 'u': + if (strcmp(op, "i64.lt_u") == 0) { return makeBinary(s, BinaryOp::LtUInt64); } + goto parse_error; + default: goto parse_error; + } + } + default: goto parse_error; + } + } + case 'm': + if (strcmp(op, "i64.mul") == 0) { return makeBinary(s, BinaryOp::MulInt64); } + goto parse_error; + case 'n': + if (strcmp(op, "i64.ne") == 0) { return makeBinary(s, BinaryOp::NeInt64); } + goto parse_error; + case 'o': + if (strcmp(op, "i64.or") == 0) { return makeBinary(s, BinaryOp::OrInt64); } + goto parse_error; + case 'p': + if (strcmp(op, "i64.popcnt") == 0) { return makeUnary(s, UnaryOp::PopcntInt64); } + goto parse_error; + case 'r': { + switch (op[5]) { + case 'e': { + switch (op[6]) { + case 'i': + if (strcmp(op, "i64.reinterpret_f64") == 0) { return makeUnary(s, UnaryOp::ReinterpretFloat64); } + goto parse_error; + case 'm': { + switch (op[8]) { + case 's': + if (strcmp(op, "i64.rem_s") == 0) { return makeBinary(s, BinaryOp::RemSInt64); } + goto parse_error; + case 'u': + if (strcmp(op, "i64.rem_u") == 0) { return makeBinary(s, BinaryOp::RemUInt64); } + goto parse_error; + default: goto parse_error; + } + } + default: goto parse_error; + } + } + case 'o': { + switch (op[7]) { + case 'l': + if (strcmp(op, "i64.rotl") == 0) { return makeBinary(s, BinaryOp::RotLInt64); } + goto parse_error; + case 'r': + if (strcmp(op, "i64.rotr") == 0) { return makeBinary(s, BinaryOp::RotRInt64); } + goto parse_error; + default: goto parse_error; + } + } + default: goto parse_error; + } + } + case 's': { + switch (op[5]) { + case 'h': { + switch (op[6]) { + case 'l': + if (strcmp(op, "i64.shl") == 0) { return makeBinary(s, BinaryOp::ShlInt64); } + goto parse_error; + case 'r': { + switch (op[8]) { + case 's': + if (strcmp(op, "i64.shr_s") == 0) { return makeBinary(s, BinaryOp::ShrSInt64); } + goto parse_error; + case 'u': + if (strcmp(op, "i64.shr_u") == 0) { return makeBinary(s, BinaryOp::ShrUInt64); } + goto parse_error; + default: goto parse_error; + } + } + default: goto parse_error; + } + } + case 't': { + switch (op[9]) { + case '\0': + if (strcmp(op, "i64.store") == 0) { return makeStore(s, Type::i64, /*isAtomic=*/false); } + goto parse_error; + case '1': + if (strcmp(op, "i64.store16") == 0) { return makeStore(s, Type::i64, /*isAtomic=*/false); } + goto parse_error; + case '3': + if (strcmp(op, "i64.store32") == 0) { return makeStore(s, Type::i64, /*isAtomic=*/false); } + goto parse_error; + case '8': + if (strcmp(op, "i64.store8") == 0) { return makeStore(s, Type::i64, /*isAtomic=*/false); } + goto parse_error; + default: goto parse_error; + } + } + case 'u': + if (strcmp(op, "i64.sub") == 0) { return makeBinary(s, BinaryOp::SubInt64); } + goto parse_error; + default: goto parse_error; + } + } + case 't': { + switch (op[10]) { + case 'f': { + switch (op[11]) { + case '3': { + switch (op[14]) { + case 's': + if (strcmp(op, "i64.trunc_f32_s") == 0) { return makeUnary(s, UnaryOp::TruncSFloat32ToInt64); } + goto parse_error; + case 'u': + if (strcmp(op, "i64.trunc_f32_u") == 0) { return makeUnary(s, UnaryOp::TruncUFloat32ToInt64); } + goto parse_error; + default: goto parse_error; + } + } + case '6': { + switch (op[14]) { + case 's': + if (strcmp(op, "i64.trunc_f64_s") == 0) { return makeUnary(s, UnaryOp::TruncSFloat64ToInt64); } + goto parse_error; + case 'u': + if (strcmp(op, "i64.trunc_f64_u") == 0) { return makeUnary(s, UnaryOp::TruncUFloat64ToInt64); } + goto parse_error; + default: goto parse_error; + } + } + default: goto parse_error; + } + } + case 's': { + switch (op[15]) { + case '3': { + switch (op[18]) { + case 's': + if (strcmp(op, "i64.trunc_sat_f32_s") == 0) { return makeUnary(s, UnaryOp::TruncSatSFloat32ToInt64); } + goto parse_error; + case 'u': + if (strcmp(op, "i64.trunc_sat_f32_u") == 0) { return makeUnary(s, UnaryOp::TruncSatUFloat32ToInt64); } + goto parse_error; + default: goto parse_error; + } + } + case '6': { + switch (op[18]) { + case 's': + if (strcmp(op, "i64.trunc_sat_f64_s") == 0) { return makeUnary(s, UnaryOp::TruncSatSFloat64ToInt64); } + goto parse_error; + case 'u': + if (strcmp(op, "i64.trunc_sat_f64_u") == 0) { return makeUnary(s, UnaryOp::TruncSatUFloat64ToInt64); } + goto parse_error; + default: goto parse_error; + } + } + default: goto parse_error; + } + } + default: goto parse_error; + } + } + case 'x': + if (strcmp(op, "i64.xor") == 0) { return makeBinary(s, BinaryOp::XorInt64); } + goto parse_error; + default: goto parse_error; + } + } + case 'x': { + switch (op[6]) { + case 'a': { + switch (op[7]) { + case 'd': + if (strcmp(op, "i64x2.add") == 0) { return makeBinary(s, BinaryOp::AddVecI64x2); } + goto parse_error; + case 'l': + if (strcmp(op, "i64x2.all_true") == 0) { return makeUnary(s, UnaryOp::AllTrueVecI64x2); } + goto parse_error; + case 'n': + if (strcmp(op, "i64x2.any_true") == 0) { return makeUnary(s, UnaryOp::AnyTrueVecI64x2); } + goto parse_error; + default: goto parse_error; + } + } + case 'e': + if (strcmp(op, "i64x2.extract_lane") == 0) { return makeSIMDExtract(s, SIMDExtractOp::ExtractLaneVecI64x2, 2); } + goto parse_error; + case 'l': { + switch (op[15]) { + case 's': + if (strcmp(op, "i64x2.load32x2_s") == 0) { return makeSIMDLoad(s, SIMDLoadOp::LoadExtSVec32x2ToVecI64x2); } + goto parse_error; + case 'u': + if (strcmp(op, "i64x2.load32x2_u") == 0) { return makeSIMDLoad(s, SIMDLoadOp::LoadExtUVec32x2ToVecI64x2); } + goto parse_error; + default: goto parse_error; + } + } + case 'm': + if (strcmp(op, "i64x2.mul") == 0) { return makeBinary(s, BinaryOp::MulVecI64x2); } + goto parse_error; + case 'n': + if (strcmp(op, "i64x2.neg") == 0) { return makeUnary(s, UnaryOp::NegVecI64x2); } + goto parse_error; + case 'r': + if (strcmp(op, "i64x2.replace_lane") == 0) { return makeSIMDReplace(s, SIMDReplaceOp::ReplaceLaneVecI64x2, 2); } + goto parse_error; + case 's': { + switch (op[7]) { + case 'h': { + switch (op[8]) { + case 'l': + if (strcmp(op, "i64x2.shl") == 0) { return makeSIMDShift(s, SIMDShiftOp::ShlVecI64x2); } + goto parse_error; + case 'r': { + switch (op[10]) { + case 's': + if (strcmp(op, "i64x2.shr_s") == 0) { return makeSIMDShift(s, SIMDShiftOp::ShrSVecI64x2); } + goto parse_error; + case 'u': + if (strcmp(op, "i64x2.shr_u") == 0) { return makeSIMDShift(s, SIMDShiftOp::ShrUVecI64x2); } + goto parse_error; + default: goto parse_error; + } + } + default: goto parse_error; + } + } + case 'p': + if (strcmp(op, "i64x2.splat") == 0) { return makeUnary(s, UnaryOp::SplatVecI64x2); } + goto parse_error; + case 'u': + if (strcmp(op, "i64x2.sub") == 0) { return makeBinary(s, BinaryOp::SubVecI64x2); } + goto parse_error; + default: goto parse_error; + } + } + case 't': { + switch (op[22]) { + case 's': + if (strcmp(op, "i64x2.trunc_sat_f64x2_s") == 0) { return makeUnary(s, UnaryOp::TruncSatSVecF64x2ToVecI64x2); } + goto parse_error; + case 'u': + if (strcmp(op, "i64x2.trunc_sat_f64x2_u") == 0) { return makeUnary(s, UnaryOp::TruncSatUVecF64x2ToVecI64x2); } + goto parse_error; + default: goto parse_error; + } + } + default: goto parse_error; + } + } + default: goto parse_error; + } + } + case '8': { + switch (op[6]) { + case 'a': { + switch (op[7]) { + case 'b': + if (strcmp(op, "i8x16.abs") == 0) { return makeUnary(s, UnaryOp::AbsVecI8x16); } + goto parse_error; + case 'd': { + switch (op[9]) { + case '\0': + if (strcmp(op, "i8x16.add") == 0) { return makeBinary(s, BinaryOp::AddVecI8x16); } + goto parse_error; + case '_': { + switch (op[19]) { + case 's': + if (strcmp(op, "i8x16.add_saturate_s") == 0) { return makeBinary(s, BinaryOp::AddSatSVecI8x16); } + goto parse_error; + case 'u': + if (strcmp(op, "i8x16.add_saturate_u") == 0) { return makeBinary(s, BinaryOp::AddSatUVecI8x16); } + goto parse_error; + default: goto parse_error; + } + } + default: goto parse_error; + } + } + case 'l': + if (strcmp(op, "i8x16.all_true") == 0) { return makeUnary(s, UnaryOp::AllTrueVecI8x16); } + goto parse_error; + case 'n': + if (strcmp(op, "i8x16.any_true") == 0) { return makeUnary(s, UnaryOp::AnyTrueVecI8x16); } + goto parse_error; + case 'v': + if (strcmp(op, "i8x16.avgr_u") == 0) { return makeBinary(s, BinaryOp::AvgrUVecI8x16); } + goto parse_error; + default: goto parse_error; + } + } + case 'b': + if (strcmp(op, "i8x16.bitmask") == 0) { return makeUnary(s, UnaryOp::BitmaskVecI8x16); } + goto parse_error; + case 'e': { + switch (op[7]) { + case 'q': + if (strcmp(op, "i8x16.eq") == 0) { return makeBinary(s, BinaryOp::EqVecI8x16); } + goto parse_error; + case 'x': { + switch (op[19]) { + case 's': + if (strcmp(op, "i8x16.extract_lane_s") == 0) { return makeSIMDExtract(s, SIMDExtractOp::ExtractLaneSVecI8x16, 16); } + goto parse_error; + case 'u': + if (strcmp(op, "i8x16.extract_lane_u") == 0) { return makeSIMDExtract(s, SIMDExtractOp::ExtractLaneUVecI8x16, 16); } + goto parse_error; + default: goto parse_error; + } + } + default: goto parse_error; + } + } + case 'g': { + switch (op[7]) { + case 'e': { + switch (op[9]) { + case 's': + if (strcmp(op, "i8x16.ge_s") == 0) { return makeBinary(s, BinaryOp::GeSVecI8x16); } + goto parse_error; + case 'u': + if (strcmp(op, "i8x16.ge_u") == 0) { return makeBinary(s, BinaryOp::GeUVecI8x16); } + goto parse_error; + default: goto parse_error; + } + } + case 't': { + switch (op[9]) { + case 's': + if (strcmp(op, "i8x16.gt_s") == 0) { return makeBinary(s, BinaryOp::GtSVecI8x16); } + goto parse_error; + case 'u': + if (strcmp(op, "i8x16.gt_u") == 0) { return makeBinary(s, BinaryOp::GtUVecI8x16); } + goto parse_error; + default: goto parse_error; + } + } + default: goto parse_error; + } + } + case 'l': { + switch (op[7]) { + case 'e': { + switch (op[9]) { + case 's': + if (strcmp(op, "i8x16.le_s") == 0) { return makeBinary(s, BinaryOp::LeSVecI8x16); } + goto parse_error; + case 'u': + if (strcmp(op, "i8x16.le_u") == 0) { return makeBinary(s, BinaryOp::LeUVecI8x16); } + goto parse_error; + default: goto parse_error; + } + } + case 't': { + switch (op[9]) { + case 's': + if (strcmp(op, "i8x16.lt_s") == 0) { return makeBinary(s, BinaryOp::LtSVecI8x16); } + goto parse_error; + case 'u': + if (strcmp(op, "i8x16.lt_u") == 0) { return makeBinary(s, BinaryOp::LtUVecI8x16); } + goto parse_error; + default: goto parse_error; + } + } + default: goto parse_error; + } + } + case 'm': { + switch (op[7]) { + case 'a': { + switch (op[10]) { + case 's': + if (strcmp(op, "i8x16.max_s") == 0) { return makeBinary(s, BinaryOp::MaxSVecI8x16); } + goto parse_error; + case 'u': + if (strcmp(op, "i8x16.max_u") == 0) { return makeBinary(s, BinaryOp::MaxUVecI8x16); } + goto parse_error; + default: goto parse_error; + } + } + case 'i': { + switch (op[10]) { + case 's': + if (strcmp(op, "i8x16.min_s") == 0) { return makeBinary(s, BinaryOp::MinSVecI8x16); } + goto parse_error; + case 'u': + if (strcmp(op, "i8x16.min_u") == 0) { return makeBinary(s, BinaryOp::MinUVecI8x16); } + goto parse_error; + default: goto parse_error; + } + } + case 'u': + if (strcmp(op, "i8x16.mul") == 0) { return makeBinary(s, BinaryOp::MulVecI8x16); } + goto parse_error; + default: goto parse_error; + } + } + case 'n': { + switch (op[7]) { + case 'a': { + switch (op[19]) { + case 's': + if (strcmp(op, "i8x16.narrow_i16x8_s") == 0) { return makeBinary(s, BinaryOp::NarrowSVecI16x8ToVecI8x16); } + goto parse_error; + case 'u': + if (strcmp(op, "i8x16.narrow_i16x8_u") == 0) { return makeBinary(s, BinaryOp::NarrowUVecI16x8ToVecI8x16); } + goto parse_error; + default: goto parse_error; + } + } + case 'e': { + switch (op[8]) { + case '\0': + if (strcmp(op, "i8x16.ne") == 0) { return makeBinary(s, BinaryOp::NeVecI8x16); } + goto parse_error; + case 'g': + if (strcmp(op, "i8x16.neg") == 0) { return makeUnary(s, UnaryOp::NegVecI8x16); } + goto parse_error; + default: goto parse_error; + } + } + default: goto parse_error; + } + } + case 'r': + if (strcmp(op, "i8x16.replace_lane") == 0) { return makeSIMDReplace(s, SIMDReplaceOp::ReplaceLaneVecI8x16, 16); } + goto parse_error; + case 's': { + switch (op[7]) { + case 'h': { + switch (op[8]) { + case 'l': + if (strcmp(op, "i8x16.shl") == 0) { return makeSIMDShift(s, SIMDShiftOp::ShlVecI8x16); } + goto parse_error; + case 'r': { + switch (op[10]) { + case 's': + if (strcmp(op, "i8x16.shr_s") == 0) { return makeSIMDShift(s, SIMDShiftOp::ShrSVecI8x16); } + goto parse_error; + case 'u': + if (strcmp(op, "i8x16.shr_u") == 0) { return makeSIMDShift(s, SIMDShiftOp::ShrUVecI8x16); } + goto parse_error; + default: goto parse_error; + } + } + default: goto parse_error; + } + } + case 'p': + if (strcmp(op, "i8x16.splat") == 0) { return makeUnary(s, UnaryOp::SplatVecI8x16); } + goto parse_error; + case 'u': { + switch (op[9]) { + case '\0': + if (strcmp(op, "i8x16.sub") == 0) { return makeBinary(s, BinaryOp::SubVecI8x16); } + goto parse_error; + case '_': { + switch (op[19]) { + case 's': + if (strcmp(op, "i8x16.sub_saturate_s") == 0) { return makeBinary(s, BinaryOp::SubSatSVecI8x16); } + goto parse_error; + case 'u': + if (strcmp(op, "i8x16.sub_saturate_u") == 0) { return makeBinary(s, BinaryOp::SubSatUVecI8x16); } + goto parse_error; + default: goto parse_error; + } + } + default: goto parse_error; + } + } + default: goto parse_error; + } + } + default: goto parse_error; + } + } + case 'f': + if (strcmp(op, "if") == 0) { return makeIf(s); } + goto parse_error; + default: goto parse_error; + } + } + case 'l': { + switch (op[2]) { + case 'c': { + switch (op[6]) { + case 'g': + if (strcmp(op, "local.get") == 0) { return makeLocalGet(s); } + goto parse_error; + case 's': + if (strcmp(op, "local.set") == 0) { return makeLocalSet(s); } + goto parse_error; + case 't': + if (strcmp(op, "local.tee") == 0) { return makeLocalTee(s); } + goto parse_error; + default: goto parse_error; + } + } + case 'o': + if (strcmp(op, "loop") == 0) { return makeLoop(s); } + goto parse_error; + default: goto parse_error; + } + } + case 'm': { + switch (op[7]) { + case 'c': + if (strcmp(op, "memory.copy") == 0) { return makeMemoryCopy(s); } + goto parse_error; + case 'f': + if (strcmp(op, "memory.fill") == 0) { return makeMemoryFill(s); } + goto parse_error; + case 'g': + if (strcmp(op, "memory.grow") == 0) { return makeMemoryGrow(s); } + goto parse_error; + case 'i': + if (strcmp(op, "memory.init") == 0) { return makeMemoryInit(s); } + goto parse_error; + case 's': + if (strcmp(op, "memory.size") == 0) { return makeMemorySize(s); } + goto parse_error; + default: goto parse_error; + } + } + case 'n': + if (strcmp(op, "nop") == 0) { return makeNop(); } + goto parse_error; + case 'p': + if (strcmp(op, "pop") == 0) { return makePop(s); } + goto parse_error; + case 'r': { + switch (op[1]) { + case 'e': { + switch (op[2]) { + case 'f': { + switch (op[4]) { + case 'c': + if (strcmp(op, "ref.cast") == 0) { return makeRefCast(s); } + goto parse_error; + case 'e': + if (strcmp(op, "ref.eq") == 0) { return makeRefEq(s); } + goto parse_error; + case 'f': + if (strcmp(op, "ref.func") == 0) { return makeRefFunc(s); } + goto parse_error; + case 'i': + if (strcmp(op, "ref.is_null") == 0) { return makeRefIsNull(s); } + goto parse_error; + case 'n': + if (strcmp(op, "ref.null") == 0) { return makeRefNull(s); } + goto parse_error; + case 't': + if (strcmp(op, "ref.test") == 0) { return makeRefTest(s); } + goto parse_error; + default: goto parse_error; + } + } + case 't': { + switch (op[3]) { + case 'h': + if (strcmp(op, "rethrow") == 0) { return makeRethrow(s); } + goto parse_error; + case 'u': { + switch (op[6]) { + case '\0': + if (strcmp(op, "return") == 0) { return makeReturn(s); } + goto parse_error; + case '_': { + switch (op[11]) { + case '\0': + if (strcmp(op, "return_call") == 0) { return makeCall(s, /*isReturn=*/true); } + goto parse_error; + case '_': + if (strcmp(op, "return_call_indirect") == 0) { return makeCallIndirect(s, /*isReturn=*/true); } + goto parse_error; + default: goto parse_error; + } + } + default: goto parse_error; + } + } + default: goto parse_error; + } + } + default: goto parse_error; + } + } + case 't': { + switch (op[4]) { + case 'c': + if (strcmp(op, "rtt.canon") == 0) { return makeRttCanon(s); } + goto parse_error; + case 's': + if (strcmp(op, "rtt.sub") == 0) { return makeRttSub(s); } + goto parse_error; + default: goto parse_error; + } + } + default: goto parse_error; + } + } + case 's': { + switch (op[1]) { + case 'e': + if (strcmp(op, "select") == 0) { return makeSelect(s); } + goto parse_error; + case 't': { + switch (op[7]) { + case 'g': { + switch (op[10]) { + case '\0': + if (strcmp(op, "struct.get") == 0) { return makeStructGet(s); } + goto parse_error; + case '_': { + switch (op[11]) { + case 's': + if (strcmp(op, "struct.get_s") == 0) { return makeStructGet(s, true); } + goto parse_error; + case 'u': + if (strcmp(op, "struct.get_u") == 0) { return makeStructGet(s, false); } + goto parse_error; + default: goto parse_error; + } + } + default: goto parse_error; + } + } + case 'n': { + switch (op[11]) { + case 'd': + if (strcmp(op, "struct.new_default_with_rtt") == 0) { return makeStructNew(s, true); } + goto parse_error; + case 'w': + if (strcmp(op, "struct.new_with_rtt") == 0) { return makeStructNew(s, false); } + goto parse_error; + default: goto parse_error; + } + } + case 's': + if (strcmp(op, "struct.set") == 0) { return makeStructSet(s); } + goto parse_error; + default: goto parse_error; + } + } + default: goto parse_error; + } + } + case 't': { + switch (op[1]) { + case 'h': { + switch (op[2]) { + case 'e': + if (strcmp(op, "then") == 0) { return makeThenOrElse(s); } + goto parse_error; + case 'r': + if (strcmp(op, "throw") == 0) { return makeThrow(s); } + goto parse_error; + default: goto parse_error; + } + } + case 'r': + if (strcmp(op, "try") == 0) { return makeTry(s); } + goto parse_error; + case 'u': { + switch (op[6]) { + case 'e': + if (strcmp(op, "tuple.extract") == 0) { return makeTupleExtract(s); } + goto parse_error; + case 'm': + if (strcmp(op, "tuple.make") == 0) { return makeTupleMake(s); } + goto parse_error; + default: goto parse_error; + } + } + default: goto parse_error; + } + } + case 'u': + if (strcmp(op, "unreachable") == 0) { return makeUnreachable(); } + goto parse_error; + case 'v': { + switch (op[1]) { + case '1': { + switch (op[2]) { + case '2': { + switch (op[5]) { + case 'a': { + switch (op[8]) { + case '\0': + if (strcmp(op, "v128.and") == 0) { return makeBinary(s, BinaryOp::AndVec128); } + goto parse_error; + case 'n': + if (strcmp(op, "v128.andnot") == 0) { return makeBinary(s, BinaryOp::AndNotVec128); } + goto parse_error; + default: goto parse_error; + } + } + case 'b': + if (strcmp(op, "v128.bitselect") == 0) { return makeSIMDTernary(s, SIMDTernaryOp::Bitselect); } + goto parse_error; + case 'c': + if (strcmp(op, "v128.const") == 0) { return makeConst(s, Type::v128); } + goto parse_error; + case 'l': { + switch (op[9]) { + case '\0': + if (strcmp(op, "v128.load") == 0) { return makeLoad(s, Type::v128, /*isAtomic=*/false); } + goto parse_error; + case '3': + if (strcmp(op, "v128.load32_zero") == 0) { return makeSIMDLoad(s, SIMDLoadOp::Load32Zero); } + goto parse_error; + case '6': + if (strcmp(op, "v128.load64_zero") == 0) { return makeSIMDLoad(s, SIMDLoadOp::Load64Zero); } + goto parse_error; + default: goto parse_error; + } + } + case 'n': + if (strcmp(op, "v128.not") == 0) { return makeUnary(s, UnaryOp::NotVec128); } + goto parse_error; + case 'o': + if (strcmp(op, "v128.or") == 0) { return makeBinary(s, BinaryOp::OrVec128); } + goto parse_error; + case 's': + if (strcmp(op, "v128.store") == 0) { return makeStore(s, Type::v128, /*isAtomic=*/false); } + goto parse_error; + case 'x': + if (strcmp(op, "v128.xor") == 0) { return makeBinary(s, BinaryOp::XorVec128); } + goto parse_error; + default: goto parse_error; + } + } + case '6': + if (strcmp(op, "v16x8.load_splat") == 0) { return makeSIMDLoad(s, SIMDLoadOp::LoadSplatVec16x8); } + goto parse_error; + default: goto parse_error; + } + } + case '3': + if (strcmp(op, "v32x4.load_splat") == 0) { return makeSIMDLoad(s, SIMDLoadOp::LoadSplatVec32x4); } + goto parse_error; + case '6': + if (strcmp(op, "v64x2.load_splat") == 0) { return makeSIMDLoad(s, SIMDLoadOp::LoadSplatVec64x2); } + goto parse_error; + case '8': { + switch (op[6]) { + case 'l': + if (strcmp(op, "v8x16.load_splat") == 0) { return makeSIMDLoad(s, SIMDLoadOp::LoadSplatVec8x16); } + goto parse_error; + case 's': { + switch (op[7]) { + case 'h': + if (strcmp(op, "v8x16.shuffle") == 0) { return makeSIMDShuffle(s); } + goto parse_error; + case 'w': + if (strcmp(op, "v8x16.swizzle") == 0) { return makeBinary(s, BinaryOp::SwizzleVec8x16); } + goto parse_error; + default: goto parse_error; + } + } + default: goto parse_error; + } + } + default: goto parse_error; + } + } + default: goto parse_error; +} +parse_error: + throw ParseException(std::string(op), s.line, s.col); +#endif // INSTRUCTION_PARSER + +// clang-format on diff --git a/binaryen/src/ir/CMakeLists.txt b/binaryen/src/ir/CMakeLists.txt new file mode 100644 --- /dev/null +++ b/binaryen/src/ir/CMakeLists.txt @@ -0,0 +1,10 @@ +FILE(GLOB ir_HEADERS *.h) +set(ir_SOURCES + ExpressionAnalyzer.cpp + ExpressionManipulator.cpp + LocalGraph.cpp + ReFinalize.cpp + stack-utils.cpp + ${ir_HEADERS} +) +add_library(ir OBJECT ${ir_SOURCES}) diff --git a/binaryen/src/ir/ExpressionAnalyzer.cpp b/binaryen/src/ir/ExpressionAnalyzer.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/ir/ExpressionAnalyzer.cpp @@ -0,0 +1,525 @@ +/* + * Copyright 2016 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "ir/iteration.h" +#include "ir/load-utils.h" +#include "ir/utils.h" +#include "support/hash.h" +#include "support/small_vector.h" +#include "wasm-traversal.h" +#include "wasm.h" + +namespace wasm { + +// Given a stack of expressions, checks if the topmost is used as a result. +// For example, if the parent is a block and the node is before the last +// position, it is not used. +bool ExpressionAnalyzer::isResultUsed(ExpressionStack& stack, Function* func) { + for (int i = int(stack.size()) - 2; i >= 0; i--) { + auto* curr = stack[i]; + auto* above = stack[i + 1]; + // only if and block can drop values (pre-drop expression was added) FIXME + if (curr->is()) { + auto* block = curr->cast(); + for (size_t j = 0; j < block->list.size() - 1; j++) { + if (block->list[j] == above) { + return false; + } + } + assert(block->list.back() == above); + // continue down + } else if (curr->is()) { + auto* iff = curr->cast(); + if (above == iff->condition) { + return true; + } + if (!iff->ifFalse) { + return false; + } + assert(above == iff->ifTrue || above == iff->ifFalse); + // continue down + } else { + if (curr->is()) { + return false; + } + return true; // all other node types use the result + } + } + // The value might be used, so it depends on if the function returns + return func->sig.results != Type::none; +} + +// Checks if a value is dropped. +bool ExpressionAnalyzer::isResultDropped(ExpressionStack& stack) { + for (int i = int(stack.size()) - 2; i >= 0; i--) { + auto* curr = stack[i]; + auto* above = stack[i + 1]; + if (curr->is()) { + auto* block = curr->cast(); + for (size_t j = 0; j < block->list.size() - 1; j++) { + if (block->list[j] == above) { + return false; + } + } + assert(block->list.back() == above); + // continue down + } else if (curr->is()) { + auto* iff = curr->cast(); + if (above == iff->condition) { + return false; + } + if (!iff->ifFalse) { + return false; + } + assert(above == iff->ifTrue || above == iff->ifFalse); + // continue down + } else { + if (curr->is()) { + return true; // dropped + } + return false; // all other node types use the result + } + } + return false; +} + +// +// Allows visiting the immediate fields of the expression. This is +// useful for comparisons and hashing. +// +// The passed-in visitor object must implement: +// * visitScopeName - a Name that represents a block or loop scope +// * visitNonScopeName - a non-scope name +// * visitInt - anything that has a short enumeration, including +// opcodes, # of bytes in a load, bools, etc. - must be +// guaranteed to fit in an int32 or less. +// * visitLiteral - a Literal +// * visitType - a Type +// * visitIndex - an Index +// * visitAddress - an Address +// + +namespace { + +template void visitImmediates(Expression* curr, T& visitor) { + struct ImmediateVisitor : public OverriddenVisitor { + T& visitor; + + ImmediateVisitor(Expression* curr, T& visitor) : visitor(visitor) { + this->visit(curr); + } + + void visitBlock(Block* curr) { visitor.visitScopeName(curr->name); } + void visitIf(If* curr) {} + void visitLoop(Loop* curr) { visitor.visitScopeName(curr->name); } + void visitBreak(Break* curr) { visitor.visitScopeName(curr->name); } + void visitSwitch(Switch* curr) { + for (auto target : curr->targets) { + visitor.visitScopeName(target); + } + visitor.visitScopeName(curr->default_); + } + void visitCall(Call* curr) { + visitor.visitNonScopeName(curr->target); + visitor.visitInt(curr->isReturn); + } + void visitCallIndirect(CallIndirect* curr) { + visitor.visitInt(curr->sig.params.getID()); + visitor.visitInt(curr->sig.results.getID()); + visitor.visitInt(curr->isReturn); + } + void visitLocalGet(LocalGet* curr) { visitor.visitIndex(curr->index); } + void visitLocalSet(LocalSet* curr) { visitor.visitIndex(curr->index); } + void visitGlobalGet(GlobalGet* curr) { + visitor.visitNonScopeName(curr->name); + } + void visitGlobalSet(GlobalSet* curr) { + visitor.visitNonScopeName(curr->name); + } + void visitLoad(Load* curr) { + visitor.visitInt(curr->bytes); + if (curr->type != Type::unreachable && + curr->bytes < curr->type.getByteSize()) { + visitor.visitInt(curr->signed_); + } + visitor.visitAddress(curr->offset); + visitor.visitAddress(curr->align); + visitor.visitInt(curr->isAtomic); + } + void visitStore(Store* curr) { + visitor.visitInt(curr->bytes); + visitor.visitAddress(curr->offset); + visitor.visitAddress(curr->align); + visitor.visitInt(curr->isAtomic); + visitor.visitInt(curr->valueType.getID()); + } + void visitAtomicRMW(AtomicRMW* curr) { + visitor.visitInt(curr->op); + visitor.visitInt(curr->bytes); + visitor.visitAddress(curr->offset); + } + void visitAtomicCmpxchg(AtomicCmpxchg* curr) { + visitor.visitInt(curr->bytes); + visitor.visitAddress(curr->offset); + } + void visitAtomicWait(AtomicWait* curr) { + visitor.visitAddress(curr->offset); + visitor.visitType(curr->expectedType); + } + void visitAtomicNotify(AtomicNotify* curr) { + visitor.visitAddress(curr->offset); + } + void visitAtomicFence(AtomicFence* curr) { visitor.visitInt(curr->order); } + void visitSIMDExtract(SIMDExtract* curr) { + visitor.visitInt(curr->op); + visitor.visitInt(curr->index); + } + void visitSIMDReplace(SIMDReplace* curr) { + visitor.visitInt(curr->op); + visitor.visitInt(curr->index); + } + void visitSIMDShuffle(SIMDShuffle* curr) { + for (auto x : curr->mask) { + visitor.visitInt(x); + } + } + void visitSIMDTernary(SIMDTernary* curr) { visitor.visitInt(curr->op); } + void visitSIMDShift(SIMDShift* curr) { visitor.visitInt(curr->op); } + void visitSIMDLoad(SIMDLoad* curr) { + visitor.visitInt(curr->op); + visitor.visitAddress(curr->offset); + visitor.visitAddress(curr->align); + } + void visitMemoryInit(MemoryInit* curr) { + visitor.visitIndex(curr->segment); + } + void visitDataDrop(DataDrop* curr) { visitor.visitIndex(curr->segment); } + void visitMemoryCopy(MemoryCopy* curr) {} + void visitMemoryFill(MemoryFill* curr) {} + void visitConst(Const* curr) { visitor.visitLiteral(curr->value); } + void visitUnary(Unary* curr) { visitor.visitInt(curr->op); } + void visitBinary(Binary* curr) { visitor.visitInt(curr->op); } + void visitSelect(Select* curr) {} + void visitDrop(Drop* curr) {} + void visitReturn(Return* curr) {} + void visitMemorySize(MemorySize* curr) {} + void visitMemoryGrow(MemoryGrow* curr) {} + void visitRefNull(RefNull* curr) { visitor.visitType(curr->type); } + void visitRefIsNull(RefIsNull* curr) {} + void visitRefFunc(RefFunc* curr) { visitor.visitNonScopeName(curr->func); } + void visitRefEq(RefEq* curr) {} + void visitTry(Try* curr) {} + void visitThrow(Throw* curr) { visitor.visitNonScopeName(curr->event); } + void visitRethrow(Rethrow* curr) {} + void visitBrOnExn(BrOnExn* curr) { + visitor.visitScopeName(curr->name); + visitor.visitNonScopeName(curr->event); + } + void visitNop(Nop* curr) {} + void visitUnreachable(Unreachable* curr) {} + void visitPop(Pop* curr) {} + void visitTupleMake(TupleMake* curr) {} + void visitTupleExtract(TupleExtract* curr) { + visitor.visitIndex(curr->index); + } + void visitI31New(I31New* curr) {} + void visitI31Get(I31Get* curr) { visitor.visitInt(curr->signed_); } + void visitRefTest(RefTest* curr) { + WASM_UNREACHABLE("TODO (gc): ref.test"); + } + void visitRefCast(RefCast* curr) { + WASM_UNREACHABLE("TODO (gc): ref.cast"); + } + void visitBrOnCast(BrOnCast* curr) { + WASM_UNREACHABLE("TODO (gc): br_on_cast"); + } + void visitRttCanon(RttCanon* curr) { + WASM_UNREACHABLE("TODO (gc): rtt.canon"); + } + void visitRttSub(RttSub* curr) { WASM_UNREACHABLE("TODO (gc): rtt.sub"); } + void visitStructNew(StructNew* curr) { + WASM_UNREACHABLE("TODO (gc): struct.new"); + } + void visitStructGet(StructGet* curr) { + WASM_UNREACHABLE("TODO (gc): struct.get"); + } + void visitStructSet(StructSet* curr) { + WASM_UNREACHABLE("TODO (gc): struct.set"); + } + void visitArrayNew(ArrayNew* curr) { + WASM_UNREACHABLE("TODO (gc): array.new"); + } + void visitArrayGet(ArrayGet* curr) { + WASM_UNREACHABLE("TODO (gc): array.get"); + } + void visitArraySet(ArraySet* curr) { + WASM_UNREACHABLE("TODO (gc): array.set"); + } + void visitArrayLen(ArrayLen* curr) { + WASM_UNREACHABLE("TODO (gc): array.len"); + } + } singleton(curr, visitor); +} + +} // namespace + +bool ExpressionAnalyzer::flexibleEqual(Expression* left, + Expression* right, + ExprComparer comparer) { + struct Comparer { + // for each name on the left, the corresponding name on the right + std::map rightNames; + std::vector leftStack; + std::vector rightStack; + + struct Immediates { + Comparer& parent; + + Immediates(Comparer& parent) : parent(parent) {} + + SmallVector scopeNames; + SmallVector nonScopeNames; + SmallVector ints; + SmallVector literals; + SmallVector types; + SmallVector indexes; + SmallVector addresses; + + void visitScopeName(Name curr) { scopeNames.push_back(curr); } + void visitNonScopeName(Name curr) { nonScopeNames.push_back(curr); } + void visitInt(int32_t curr) { ints.push_back(curr); } + void visitLiteral(Literal curr) { literals.push_back(curr); } + void visitType(Type curr) { types.push_back(curr); } + void visitIndex(Index curr) { indexes.push_back(curr); } + void visitAddress(Address curr) { addresses.push_back(curr); } + + // Comparison is by value, except for names, which must match. + bool operator==(const Immediates& other) { + if (scopeNames.size() != other.scopeNames.size()) { + return false; + } + for (Index i = 0; i < scopeNames.size(); i++) { + auto leftName = scopeNames[i]; + auto rightName = other.scopeNames[i]; + auto iter = parent.rightNames.find(leftName); + // If it's not found, that means it was defined out of the expression + // being compared, in which case we can just treat it literally - it + // must be exactly identical. + if (iter != parent.rightNames.end()) { + leftName = iter->second; + } + if (leftName != rightName) { + return false; + } + } + if (nonScopeNames != other.nonScopeNames) { + return false; + } + if (ints != other.ints) { + return false; + } + if (literals != other.literals) { + return false; + } + if (types != other.types) { + return false; + } + if (indexes != other.indexes) { + return false; + } + if (addresses != other.addresses) { + return false; + } + return true; + } + + bool operator!=(const Immediates& other) { return !(*this == other); } + + void clear() { + scopeNames.clear(); + nonScopeNames.clear(); + ints.clear(); + literals.clear(); + types.clear(); + indexes.clear(); + addresses.clear(); + } + }; + + bool noteNames(Name left, Name right) { + if (left.is() != right.is()) { + return false; + } + if (left.is()) { + assert(rightNames.find(left) == rightNames.end()); + rightNames[left] = right; + } + return true; + } + + bool compare(Expression* left, Expression* right, ExprComparer comparer) { + Immediates leftImmediates(*this), rightImmediates(*this); + + // The empty name is the same on both sides. + rightNames[Name()] = Name(); + + leftStack.push_back(left); + rightStack.push_back(right); + + while (leftStack.size() > 0 && rightStack.size() > 0) { + left = leftStack.back(); + leftStack.pop_back(); + right = rightStack.back(); + rightStack.pop_back(); + if (!left != !right) { + return false; + } + if (!left) { + continue; + } + if (comparer(left, right)) { + continue; // comparison hook, before all the rest + } + // continue with normal structural comparison + if (left->_id != right->_id) { + return false; + } + // Blocks and loops introduce scoping. + if (auto* block = left->dynCast()) { + if (!noteNames(block->name, right->cast()->name)) { + return false; + } + } else if (auto* loop = left->dynCast()) { + if (!noteNames(loop->name, right->cast()->name)) { + return false; + } + } else { + // For all other nodes, compare their immediate values + visitImmediates(left, leftImmediates); + visitImmediates(right, rightImmediates); + if (leftImmediates != rightImmediates) { + return false; + } + leftImmediates.clear(); + rightImmediates.clear(); + } + // Add child nodes. + Index counter = 0; + for (auto* child : ChildIterator(left)) { + leftStack.push_back(child); + counter++; + } + for (auto* child : ChildIterator(right)) { + rightStack.push_back(child); + counter--; + } + // The number of child nodes must match (e.g. return has an optional + // one). + if (counter != 0) { + return false; + } + } + if (leftStack.size() > 0 || rightStack.size() > 0) { + return false; + } + return true; + } + }; + + return Comparer().compare(left, right, comparer); +} + +// hash an expression, ignoring superficial details like specific internal names +size_t ExpressionAnalyzer::hash(Expression* curr) { + struct Hasher { + size_t digest = wasm::hash(0); + + Index internalCounter = 0; + // for each internal name, its unique id + std::map internalNames; + ExpressionStack stack; + + void noteScopeName(Name curr) { + if (curr.is()) { + internalNames[curr] = internalCounter++; + } + } + + Hasher(Expression* curr) { + stack.push_back(curr); + + while (stack.size() > 0) { + curr = stack.back(); + stack.pop_back(); + if (!curr) { + continue; + } + rehash(digest, curr->_id); + // we often don't need to hash the type, as it is tied to other values + // we are hashing anyhow, but there are exceptions: for example, a + // local.get's type is determined by the function, so if we are + // hashing only expression fragments, then two from different + // functions may turn out the same even if the type differs. Likewise, + // if we hash between modules, then we need to take int account + // call_imports type, etc. The simplest thing is just to hash the + // type for all of them. + rehash(digest, curr->type.getID()); + // Blocks and loops introduce scoping. + if (auto* block = curr->dynCast()) { + noteScopeName(block->name); + } else if (auto* loop = curr->dynCast()) { + noteScopeName(loop->name); + } else { + // For all other nodes, compare their immediate values + visitImmediates(curr, *this); + } + // Hash children + Index counter = 0; + for (auto* child : ChildIterator(curr)) { + stack.push_back(child); + counter++; + } + // Sometimes children are optional, e.g. return, so we must hash + // their number as well. + rehash(digest, counter); + } + } + + void visitScopeName(Name curr) { + // Names are relative, we give the same hash for + // (block $x (br $x)) + // (block $y (br $y)) + static_assert(sizeof(Index) == sizeof(int32_t), + "wasm64 will need changes here"); + assert(internalNames.find(curr) != internalNames.end()); + rehash(digest, internalNames[curr]); + } + void visitNonScopeName(Name curr) { rehash(digest, uint64_t(curr.str)); } + void visitInt(int32_t curr) { rehash(digest, curr); } + void visitLiteral(Literal curr) { rehash(digest, curr); } + void visitType(Type curr) { rehash(digest, curr.getID()); } + void visitIndex(Index curr) { + static_assert(sizeof(Index) == sizeof(uint32_t), + "wasm64 will need changes here"); + rehash(digest, curr); + } + void visitAddress(Address curr) { rehash(digest, curr.addr); } + }; + + return Hasher(curr).digest; +} + +} // namespace wasm diff --git a/binaryen/src/ir/ExpressionManipulator.cpp b/binaryen/src/ir/ExpressionManipulator.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/ir/ExpressionManipulator.cpp @@ -0,0 +1,338 @@ +/* + * Copyright 2017 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "ir/load-utils.h" +#include "ir/utils.h" + +namespace wasm { + +namespace ExpressionManipulator { + +Expression* +flexibleCopy(Expression* original, Module& wasm, CustomCopier custom) { + struct Copier : public OverriddenVisitor { + Module& wasm; + CustomCopier custom; + + Builder builder; + + Copier(Module& wasm, CustomCopier custom) + : wasm(wasm), custom(custom), builder(wasm) {} + + Expression* copy(Expression* curr) { + if (!curr) { + return nullptr; + } + auto* ret = custom(curr); + if (ret) { + return ret; + } + return OverriddenVisitor::visit(curr); + } + + Expression* visitBlock(Block* curr) { + ExpressionList list(wasm.allocator); + for (Index i = 0; i < curr->list.size(); i++) { + list.push_back(copy(curr->list[i])); + } + return builder.makeBlock(curr->name, list, curr->type); + } + Expression* visitIf(If* curr) { + return builder.makeIf(copy(curr->condition), + copy(curr->ifTrue), + copy(curr->ifFalse), + curr->type); + } + Expression* visitLoop(Loop* curr) { + return builder.makeLoop(curr->name, copy(curr->body), curr->type); + } + Expression* visitBreak(Break* curr) { + return builder.makeBreak( + curr->name, copy(curr->value), copy(curr->condition)); + } + Expression* visitSwitch(Switch* curr) { + return builder.makeSwitch(curr->targets, + curr->default_, + copy(curr->condition), + copy(curr->value)); + } + Expression* visitCall(Call* curr) { + auto* ret = + builder.makeCall(curr->target, {}, curr->type, curr->isReturn); + for (Index i = 0; i < curr->operands.size(); i++) { + ret->operands.push_back(copy(curr->operands[i])); + } + return ret; + } + Expression* visitCallIndirect(CallIndirect* curr) { + std::vector copiedOps; + for (auto op : curr->operands) { + copiedOps.push_back(copy(op)); + } + return builder.makeCallIndirect( + copy(curr->target), copiedOps, curr->sig, curr->isReturn); + } + Expression* visitLocalGet(LocalGet* curr) { + return builder.makeLocalGet(curr->index, curr->type); + } + Expression* visitLocalSet(LocalSet* curr) { + if (curr->isTee()) { + return builder.makeLocalTee(curr->index, copy(curr->value), curr->type); + } else { + return builder.makeLocalSet(curr->index, copy(curr->value)); + } + } + Expression* visitGlobalGet(GlobalGet* curr) { + return builder.makeGlobalGet(curr->name, curr->type); + } + Expression* visitGlobalSet(GlobalSet* curr) { + return builder.makeGlobalSet(curr->name, copy(curr->value)); + } + Expression* visitLoad(Load* curr) { + if (curr->isAtomic) { + return builder.makeAtomicLoad( + curr->bytes, curr->offset, copy(curr->ptr), curr->type); + } + return builder.makeLoad(curr->bytes, + LoadUtils::isSignRelevant(curr) ? curr->signed_ + : false, + curr->offset, + curr->align, + copy(curr->ptr), + curr->type); + } + Expression* visitStore(Store* curr) { + if (curr->isAtomic) { + return builder.makeAtomicStore(curr->bytes, + curr->offset, + copy(curr->ptr), + copy(curr->value), + curr->valueType); + } + return builder.makeStore(curr->bytes, + curr->offset, + curr->align, + copy(curr->ptr), + copy(curr->value), + curr->valueType); + } + Expression* visitAtomicRMW(AtomicRMW* curr) { + return builder.makeAtomicRMW(curr->op, + curr->bytes, + curr->offset, + copy(curr->ptr), + copy(curr->value), + curr->type); + } + Expression* visitAtomicCmpxchg(AtomicCmpxchg* curr) { + return builder.makeAtomicCmpxchg(curr->bytes, + curr->offset, + copy(curr->ptr), + copy(curr->expected), + copy(curr->replacement), + curr->type); + } + Expression* visitAtomicWait(AtomicWait* curr) { + return builder.makeAtomicWait(copy(curr->ptr), + copy(curr->expected), + copy(curr->timeout), + curr->expectedType, + curr->offset); + } + Expression* visitAtomicNotify(AtomicNotify* curr) { + return builder.makeAtomicNotify( + copy(curr->ptr), copy(curr->notifyCount), curr->offset); + } + Expression* visitAtomicFence(AtomicFence* curr) { + return builder.makeAtomicFence(); + } + Expression* visitSIMDExtract(SIMDExtract* curr) { + return builder.makeSIMDExtract(curr->op, copy(curr->vec), curr->index); + } + Expression* visitSIMDReplace(SIMDReplace* curr) { + return builder.makeSIMDReplace( + curr->op, copy(curr->vec), curr->index, copy(curr->value)); + } + Expression* visitSIMDShuffle(SIMDShuffle* curr) { + return builder.makeSIMDShuffle( + copy(curr->left), copy(curr->right), curr->mask); + } + Expression* visitSIMDTernary(SIMDTernary* curr) { + return builder.makeSIMDTernary( + curr->op, copy(curr->a), copy(curr->b), copy(curr->c)); + } + Expression* visitSIMDShift(SIMDShift* curr) { + return builder.makeSIMDShift( + curr->op, copy(curr->vec), copy(curr->shift)); + } + Expression* visitSIMDLoad(SIMDLoad* curr) { + return builder.makeSIMDLoad( + curr->op, curr->offset, curr->align, copy(curr->ptr)); + } + Expression* visitConst(Const* curr) { + return builder.makeConst(curr->value); + } + Expression* visitMemoryInit(MemoryInit* curr) { + return builder.makeMemoryInit( + curr->segment, copy(curr->dest), copy(curr->offset), copy(curr->size)); + } + Expression* visitDataDrop(DataDrop* curr) { + return builder.makeDataDrop(curr->segment); + } + Expression* visitMemoryCopy(MemoryCopy* curr) { + return builder.makeMemoryCopy( + copy(curr->dest), copy(curr->source), copy(curr->size)); + } + Expression* visitMemoryFill(MemoryFill* curr) { + return builder.makeMemoryFill( + copy(curr->dest), copy(curr->value), copy(curr->size)); + } + Expression* visitUnary(Unary* curr) { + return builder.makeUnary(curr->op, copy(curr->value)); + } + Expression* visitBinary(Binary* curr) { + return builder.makeBinary(curr->op, copy(curr->left), copy(curr->right)); + } + Expression* visitSelect(Select* curr) { + return builder.makeSelect(copy(curr->condition), + copy(curr->ifTrue), + copy(curr->ifFalse), + curr->type); + } + Expression* visitDrop(Drop* curr) { + return builder.makeDrop(copy(curr->value)); + } + Expression* visitReturn(Return* curr) { + return builder.makeReturn(copy(curr->value)); + } + Expression* visitMemorySize(MemorySize* curr) { + return builder.makeMemorySize(); + } + Expression* visitMemoryGrow(MemoryGrow* curr) { + return builder.makeMemoryGrow(copy(curr->delta)); + } + Expression* visitRefNull(RefNull* curr) { + return builder.makeRefNull(curr->type); + } + Expression* visitRefIsNull(RefIsNull* curr) { + return builder.makeRefIsNull(copy(curr->value)); + } + Expression* visitRefFunc(RefFunc* curr) { + return builder.makeRefFunc(curr->func); + } + Expression* visitRefEq(RefEq* curr) { + return builder.makeRefEq(copy(curr->left), copy(curr->right)); + } + Expression* visitTry(Try* curr) { + return builder.makeTry( + copy(curr->body), copy(curr->catchBody), curr->type); + } + Expression* visitThrow(Throw* curr) { + std::vector operands; + for (Index i = 0; i < curr->operands.size(); i++) { + operands.push_back(copy(curr->operands[i])); + } + return builder.makeThrow(curr->event, std::move(operands)); + } + Expression* visitRethrow(Rethrow* curr) { + return builder.makeRethrow(copy(curr->exnref)); + } + Expression* visitBrOnExn(BrOnExn* curr) { + return builder.makeBrOnExn( + curr->name, curr->event, copy(curr->exnref), curr->sent); + } + Expression* visitNop(Nop* curr) { return builder.makeNop(); } + Expression* visitUnreachable(Unreachable* curr) { + return builder.makeUnreachable(); + } + Expression* visitPop(Pop* curr) { return builder.makePop(curr->type); } + Expression* visitTupleMake(TupleMake* curr) { + std::vector operands; + for (auto* op : curr->operands) { + operands.push_back(copy(op)); + } + return builder.makeTupleMake(std::move(operands)); + } + Expression* visitTupleExtract(TupleExtract* curr) { + return builder.makeTupleExtract(copy(curr->tuple), curr->index); + } + Expression* visitI31New(I31New* curr) { + return builder.makeI31New(copy(curr->value)); + } + Expression* visitI31Get(I31Get* curr) { + return builder.makeI31Get(copy(curr->i31), curr->signed_); + } + Expression* visitRefTest(RefTest* curr) { + WASM_UNREACHABLE("TODO (gc): ref.test"); + } + Expression* visitRefCast(RefCast* curr) { + WASM_UNREACHABLE("TODO (gc): ref.cast"); + } + Expression* visitBrOnCast(BrOnCast* curr) { + WASM_UNREACHABLE("TODO (gc): br_on_cast"); + } + Expression* visitRttCanon(RttCanon* curr) { + WASM_UNREACHABLE("TODO (gc): rtt.canon"); + } + Expression* visitRttSub(RttSub* curr) { + WASM_UNREACHABLE("TODO (gc): rtt.sub"); + } + Expression* visitStructNew(StructNew* curr) { + WASM_UNREACHABLE("TODO (gc): struct.new"); + } + Expression* visitStructGet(StructGet* curr) { + WASM_UNREACHABLE("TODO (gc): struct.get"); + } + Expression* visitStructSet(StructSet* curr) { + WASM_UNREACHABLE("TODO (gc): struct.set"); + } + Expression* visitArrayNew(ArrayNew* curr) { + WASM_UNREACHABLE("TODO (gc): array.new"); + } + Expression* visitArrayGet(ArrayGet* curr) { + WASM_UNREACHABLE("TODO (gc): array.get"); + } + Expression* visitArraySet(ArraySet* curr) { + WASM_UNREACHABLE("TODO (gc): array.set"); + } + Expression* visitArrayLen(ArrayLen* curr) { + WASM_UNREACHABLE("TODO (gc): array.len"); + } + }; + + Copier copier(wasm, custom); + return copier.copy(original); +} + +// Splice an item into the middle of a block's list +void spliceIntoBlock(Block* block, Index index, Expression* add) { + auto& list = block->list; + if (index == list.size()) { + list.push_back(add); // simple append + } else { + // we need to make room + list.push_back(nullptr); + for (Index i = list.size() - 1; i > index; i--) { + list[i] = list[i - 1]; + } + list[index] = add; + } + block->finalize(block->type); +} + +} // namespace ExpressionManipulator + +} // namespace wasm diff --git a/binaryen/src/ir/LocalGraph.cpp b/binaryen/src/ir/LocalGraph.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/ir/LocalGraph.cpp @@ -0,0 +1,296 @@ +/* + * Copyright 2017 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +#include +#include +#include +#include +#include + +namespace wasm { + +namespace LocalGraphInternal { + +// Information about a basic block. +struct Info { + // actions occurring in this block: local.gets and local.sets + std::vector actions; + // for each index, the last local.set for it + std::unordered_map lastSets; +}; + +// flow helper class. flows the gets to their sets + +struct Flower : public CFGWalker, Info> { + LocalGraph::GetSetses& getSetses; + LocalGraph::Locations& locations; + + Flower(LocalGraph::GetSetses& getSetses, + LocalGraph::Locations& locations, + Function* func) + : getSetses(getSetses), locations(locations) { + setFunction(func); + // create the CFG by walking the IR + CFGWalker, Info>::doWalkFunction(func); + // flow gets across blocks + flow(func); + } + + BasicBlock* makeBasicBlock() { return new BasicBlock(); } + + // cfg traversal work + + static void doVisitLocalGet(Flower* self, Expression** currp) { + auto* curr = (*currp)->cast(); + // if in unreachable code, skip + if (!self->currBasicBlock) { + return; + } + self->currBasicBlock->contents.actions.emplace_back(curr); + self->locations[curr] = currp; + } + + static void doVisitLocalSet(Flower* self, Expression** currp) { + auto* curr = (*currp)->cast(); + // if in unreachable code, skip + if (!self->currBasicBlock) { + return; + } + self->currBasicBlock->contents.actions.emplace_back(curr); + self->currBasicBlock->contents.lastSets[curr->index] = curr; + self->locations[curr] = currp; + } + + void flow(Function* func) { + // This block struct is optimized for this flow process (Minimal + // information, iteration index). + struct FlowBlock { + // Last Traversed Iteration: This value helps us to find if this block has + // been seen while traversing blocks. We compare this value to the current + // iteration index in order to determine if we already process this block + // in the current iteration. This speeds up the processing compared to + // unordered_set or other struct usage. (No need to reset internal values, + // lookup into container, ...) + size_t lastTraversedIteration; + std::vector actions; + std::vector in; + // Sor each index, the last local.set for it + // The unordered_map from BasicBlock.Info is converted into a vector + // This speeds up search as there are usually few sets in a block, so just + // scanning them linearly is efficient, avoiding hash computations (while + // in Info, it's convenient to have a map so we can assign them easily, + // where the last one seen overwrites the previous; and, we do that O(1)). + std::vector> lastSets; + }; + + auto numLocals = func->getNumLocals(); + std::vector> allGets; + allGets.resize(numLocals); + std::vector work; + + // Convert input blocks (basicBlocks) into more efficient flow blocks to + // improve memory access. + std::vector flowBlocks; + flowBlocks.resize(basicBlocks.size()); + + // Init mapping between basicblocks and flowBlocks + std::unordered_map basicToFlowMap; + for (Index i = 0; i < basicBlocks.size(); ++i) { + basicToFlowMap[basicBlocks[i].get()] = &flowBlocks[i]; + } + + const size_t NULL_ITERATION = -1; + + FlowBlock* entryFlowBlock = nullptr; + for (Index i = 0; i < flowBlocks.size(); ++i) { + auto& block = basicBlocks[i]; + auto& flowBlock = flowBlocks[i]; + // Get the equivalent block to entry in the flow list + if (block.get() == entry) { + entryFlowBlock = &flowBlock; + } + flowBlock.lastTraversedIteration = NULL_ITERATION; + flowBlock.actions.swap(block->contents.actions); + // Map in block to flow blocks + auto& in = block->in; + flowBlock.in.resize(in.size()); + std::transform(in.begin(), + in.end(), + flowBlock.in.begin(), + [&](BasicBlock* block) { return basicToFlowMap[block]; }); + // Convert unordered_map to vector. + flowBlock.lastSets.reserve(block->contents.lastSets.size()); + for (auto set : block->contents.lastSets) { + flowBlock.lastSets.emplace_back(std::make_pair(set.first, set.second)); + } + } + assert(entryFlowBlock != nullptr); + + size_t currentIteration = 0; + for (auto& block : flowBlocks) { +#ifdef LOCAL_GRAPH_DEBUG + std::cout << "basic block " << block.get() << " :\n"; + for (auto& action : block->contents.actions) { + std::cout << " action: " << *action << '\n'; + } + for (auto* lastSet : block->contents.lastSets) { + std::cout << " last set " << lastSet << '\n'; + } +#endif + // go through the block, finding each get and adding it to its index, + // and seeing how sets affect that + auto& actions = block.actions; + // move towards the front, handling things as we go + for (int i = int(actions.size()) - 1; i >= 0; i--) { + auto* action = actions[i]; + if (auto* get = action->dynCast()) { + allGets[get->index].push_back(get); + } else { + // This set is the only set for all those gets. + auto* set = action->cast(); + auto& gets = allGets[set->index]; + for (auto* get : gets) { + getSetses[get].insert(set); + } + gets.clear(); + } + } + // If anything is left, we must flow it back through other blocks. we + // can do that for all gets as a whole, they will get the same results. + for (Index index = 0; index < numLocals; index++) { + auto& gets = allGets[index]; + if (gets.empty()) { + continue; + } + work.push_back(&block); + // Note that we may need to revisit the later parts of this initial + // block, if we are in a loop, so don't mark it as seen. + while (!work.empty()) { + auto* curr = work.back(); + work.pop_back(); + // We have gone through this block; now we must handle flowing to + // the inputs. + if (curr->in.empty()) { + if (curr == entryFlowBlock) { + // These receive a param or zero init value. + for (auto* get : gets) { + getSetses[get].insert(nullptr); + } + } + } else { + for (auto* pred : curr->in) { + if (pred->lastTraversedIteration == currentIteration) { + // We've already seen pred in this iteration. + continue; + } + pred->lastTraversedIteration = currentIteration; + auto lastSet = + std::find_if(pred->lastSets.begin(), + pred->lastSets.end(), + [&](std::pair& value) { + return value.first == index; + }); + if (lastSet != pred->lastSets.end()) { + // There is a set here, apply it, and stop the flow. + for (auto* get : gets) { + getSetses[get].insert(lastSet->second); + } + } else { + // Keep on flowing. + work.push_back(pred); + } + } + } + } + gets.clear(); + currentIteration++; + } + } + } +}; + +} // namespace LocalGraphInternal + +// LocalGraph implementation + +LocalGraph::LocalGraph(Function* func) { + LocalGraphInternal::Flower flower(getSetses, locations, func); + +#ifdef LOCAL_GRAPH_DEBUG + std::cout << "LocalGraph::dump\n"; + for (auto& pair : getSetses) { + auto* get = pair.first; + auto& sets = pair.second; + std::cout << "GET\n" << get << " is influenced by\n"; + for (auto* set : sets) { + std::cout << set << '\n'; + } + } + std::cout << "total locations: " << locations.size() << '\n'; +#endif +} + +void LocalGraph::computeInfluences() { + for (auto& pair : locations) { + auto* curr = pair.first; + if (auto* set = curr->dynCast()) { + FindAll findAll(set->value); + for (auto* get : findAll.list) { + getInfluences[get].insert(set); + } + } else { + auto* get = curr->cast(); + for (auto* set : getSetses[get]) { + setInfluences[set].insert(get); + } + } + } +} + +void LocalGraph::computeSSAIndexes() { + std::unordered_map> indexSets; + for (auto& pair : getSetses) { + auto* get = pair.first; + auto& sets = pair.second; + for (auto* set : sets) { + indexSets[get->index].insert(set); + } + } + for (auto& pair : locations) { + auto* curr = pair.first; + if (auto* set = curr->dynCast()) { + auto& sets = indexSets[set->index]; + if (sets.size() == 1 && *sets.begin() != curr) { + // While it has just one set, it is not the right one (us), + // so mark it invalid. + sets.clear(); + } + } + } + for (auto& pair : indexSets) { + auto index = pair.first; + auto& sets = pair.second; + if (sets.size() == 1) { + SSAIndexes.insert(index); + } + } +} + +bool LocalGraph::isSSA(Index x) { return SSAIndexes.count(x); } + +} // namespace wasm diff --git a/binaryen/src/ir/ReFinalize.cpp b/binaryen/src/ir/ReFinalize.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/ir/ReFinalize.cpp @@ -0,0 +1,213 @@ +/* + * Copyright 2018 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "ir/branch-utils.h" +#include "ir/find_all.h" +#include "ir/utils.h" + +namespace wasm { + +static Type getValueType(Expression* value) { + return value ? value->type : Type::none; +} + +namespace { + +// Handles a branch fixup for visitBlock: if the branch goes to the +// target name, give it a value which is unreachable. +template +void handleBranchForVisitBlock(T* curr, Name name, Module* module) { + if (BranchUtils::getUniqueTargets(curr).count(name)) { + assert(!curr->value); + Builder builder(*module); + curr->value = builder.makeUnreachable(); + } +} + +} // anonymous namespace + +void ReFinalize::visitBlock(Block* curr) { + if (curr->list.size() == 0) { + curr->type = Type::none; + return; + } + // Get the least upper bound type of the last element and all branch return + // values + curr->type = curr->list.back()->type; + if (curr->name.is()) { + auto iter = breakValues.find(curr->name); + if (iter != breakValues.end()) { + curr->type = Type::getLeastUpperBound(curr->type, iter->second); + return; + } + } + if (curr->type == Type::unreachable) { + return; + } + // type is none, but we might be unreachable + if (curr->type == Type::none) { + for (auto* child : curr->list) { + if (child->type == Type::unreachable) { + curr->type = Type::unreachable; + break; + } + } + } +} +void ReFinalize::visitIf(If* curr) { curr->finalize(); } +void ReFinalize::visitLoop(Loop* curr) { curr->finalize(); } +void ReFinalize::visitBreak(Break* curr) { + curr->finalize(); + auto valueType = getValueType(curr->value); + if (valueType == Type::unreachable) { + replaceUntaken(curr->value, curr->condition); + } else { + updateBreakValueType(curr->name, valueType); + } +} +void ReFinalize::visitSwitch(Switch* curr) { + curr->finalize(); + auto valueType = getValueType(curr->value); + if (valueType == Type::unreachable) { + replaceUntaken(curr->value, curr->condition); + } else { + for (auto target : curr->targets) { + updateBreakValueType(target, valueType); + } + updateBreakValueType(curr->default_, valueType); + } +} +void ReFinalize::visitCall(Call* curr) { curr->finalize(); } +void ReFinalize::visitCallIndirect(CallIndirect* curr) { curr->finalize(); } +void ReFinalize::visitLocalGet(LocalGet* curr) { curr->finalize(); } +void ReFinalize::visitLocalSet(LocalSet* curr) { curr->finalize(); } +void ReFinalize::visitGlobalGet(GlobalGet* curr) { curr->finalize(); } +void ReFinalize::visitGlobalSet(GlobalSet* curr) { curr->finalize(); } +void ReFinalize::visitLoad(Load* curr) { curr->finalize(); } +void ReFinalize::visitStore(Store* curr) { curr->finalize(); } +void ReFinalize::visitAtomicRMW(AtomicRMW* curr) { curr->finalize(); } +void ReFinalize::visitAtomicCmpxchg(AtomicCmpxchg* curr) { curr->finalize(); } +void ReFinalize::visitAtomicWait(AtomicWait* curr) { curr->finalize(); } +void ReFinalize::visitAtomicNotify(AtomicNotify* curr) { curr->finalize(); } +void ReFinalize::visitAtomicFence(AtomicFence* curr) { curr->finalize(); } +void ReFinalize::visitSIMDExtract(SIMDExtract* curr) { curr->finalize(); } +void ReFinalize::visitSIMDReplace(SIMDReplace* curr) { curr->finalize(); } +void ReFinalize::visitSIMDShuffle(SIMDShuffle* curr) { curr->finalize(); } +void ReFinalize::visitSIMDTernary(SIMDTernary* curr) { curr->finalize(); } +void ReFinalize::visitSIMDShift(SIMDShift* curr) { curr->finalize(); } +void ReFinalize::visitSIMDLoad(SIMDLoad* curr) { curr->finalize(); } +void ReFinalize::visitMemoryInit(MemoryInit* curr) { curr->finalize(); } +void ReFinalize::visitDataDrop(DataDrop* curr) { curr->finalize(); } +void ReFinalize::visitMemoryCopy(MemoryCopy* curr) { curr->finalize(); } +void ReFinalize::visitMemoryFill(MemoryFill* curr) { curr->finalize(); } +void ReFinalize::visitConst(Const* curr) { curr->finalize(); } +void ReFinalize::visitUnary(Unary* curr) { curr->finalize(); } +void ReFinalize::visitBinary(Binary* curr) { curr->finalize(); } +void ReFinalize::visitSelect(Select* curr) { curr->finalize(); } +void ReFinalize::visitDrop(Drop* curr) { curr->finalize(); } +void ReFinalize::visitReturn(Return* curr) { curr->finalize(); } +void ReFinalize::visitMemorySize(MemorySize* curr) { curr->finalize(); } +void ReFinalize::visitMemoryGrow(MemoryGrow* curr) { curr->finalize(); } +void ReFinalize::visitRefNull(RefNull* curr) { curr->finalize(); } +void ReFinalize::visitRefIsNull(RefIsNull* curr) { curr->finalize(); } +void ReFinalize::visitRefFunc(RefFunc* curr) { curr->finalize(); } +void ReFinalize::visitRefEq(RefEq* curr) { curr->finalize(); } +void ReFinalize::visitTry(Try* curr) { curr->finalize(); } +void ReFinalize::visitThrow(Throw* curr) { curr->finalize(); } +void ReFinalize::visitRethrow(Rethrow* curr) { curr->finalize(); } +void ReFinalize::visitBrOnExn(BrOnExn* curr) { + curr->finalize(); + if (curr->exnref->type == Type::unreachable) { + replaceUntaken(curr->exnref, nullptr); + } else { + updateBreakValueType(curr->name, curr->sent); + } +} +void ReFinalize::visitNop(Nop* curr) { curr->finalize(); } +void ReFinalize::visitUnreachable(Unreachable* curr) { curr->finalize(); } +void ReFinalize::visitPop(Pop* curr) { curr->finalize(); } +void ReFinalize::visitTupleMake(TupleMake* curr) { curr->finalize(); } +void ReFinalize::visitTupleExtract(TupleExtract* curr) { curr->finalize(); } +void ReFinalize::visitI31New(I31New* curr) { curr->finalize(); } +void ReFinalize::visitI31Get(I31Get* curr) { curr->finalize(); } +void ReFinalize::visitRefTest(RefTest* curr) { curr->finalize(); } +void ReFinalize::visitRefCast(RefCast* curr) { curr->finalize(); } +void ReFinalize::visitBrOnCast(BrOnCast* curr) { + curr->finalize(); + WASM_UNREACHABLE("TODO (gc): br_on_cast"); +} +void ReFinalize::visitRttCanon(RttCanon* curr) { curr->finalize(); } +void ReFinalize::visitRttSub(RttSub* curr) { curr->finalize(); } +void ReFinalize::visitStructNew(StructNew* curr) { curr->finalize(); } +void ReFinalize::visitStructGet(StructGet* curr) { curr->finalize(); } +void ReFinalize::visitStructSet(StructSet* curr) { curr->finalize(); } +void ReFinalize::visitArrayNew(ArrayNew* curr) { curr->finalize(); } +void ReFinalize::visitArrayGet(ArrayGet* curr) { curr->finalize(); } +void ReFinalize::visitArraySet(ArraySet* curr) { curr->finalize(); } +void ReFinalize::visitArrayLen(ArrayLen* curr) { curr->finalize(); } + +void ReFinalize::visitFunction(Function* curr) { + // we may have changed the body from unreachable to none, which might be bad + // if the function has a return value + if (curr->sig.results != Type::none && curr->body->type == Type::none) { + Builder builder(*getModule()); + curr->body = builder.blockify(curr->body, builder.makeUnreachable()); + } +} + +void ReFinalize::visitExport(Export* curr) { WASM_UNREACHABLE("unimp"); } +void ReFinalize::visitGlobal(Global* curr) { WASM_UNREACHABLE("unimp"); } +void ReFinalize::visitTable(Table* curr) { WASM_UNREACHABLE("unimp"); } +void ReFinalize::visitMemory(Memory* curr) { WASM_UNREACHABLE("unimp"); } +void ReFinalize::visitEvent(Event* curr) { WASM_UNREACHABLE("unimp"); } +void ReFinalize::visitModule(Module* curr) { WASM_UNREACHABLE("unimp"); } + +void ReFinalize::updateBreakValueType(Name name, Type type) { + if (type != Type::unreachable) { + if (breakValues.count(name) == 0) { + breakValues[name] = type; + } else { + breakValues[name] = Type::getLeastUpperBound(breakValues[name], type); + } + } +} + +// Replace an untaken branch/switch with an unreachable value. +// A condition may also exist and may or may not be unreachable. +void ReFinalize::replaceUntaken(Expression* value, Expression* condition) { + assert(value->type == Type::unreachable); + auto* replacement = value; + if (condition) { + Builder builder(*getModule()); + // Even if we have + // (block + // (unreachable) + // (i32.const 1) + // ) + // we want the block type to be unreachable. That is valid as + // the value is unreachable, and necessary since the type of + // the condition did not have an impact before (the break/switch + // type was unreachable), and might not fit in. + if (condition->type.isConcrete()) { + condition = builder.makeDrop(condition); + } + replacement = builder.makeSequence(value, condition); + assert(replacement->type.isBasic() && "Basic type expected"); + } + replaceCurrent(replacement); +} + +} // namespace wasm diff --git a/binaryen/src/ir/abstract.h b/binaryen/src/ir/abstract.h new file mode 100644 --- /dev/null +++ b/binaryen/src/ir/abstract.h @@ -0,0 +1,302 @@ +/* + * Copyright 2018 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// Abstracts out operations from specific opcodes. + +#ifndef wasm_ir_abstract_h +#define wasm_ir_abstract_h + +#include + +namespace wasm { + +namespace Abstract { + +enum Op { + // Unary + Neg, + // Binary + Add, + Sub, + Mul, + DivU, + DivS, + Rem, + RemU, + RemS, + Shl, + ShrU, + ShrS, + RotL, + RotR, + And, + Or, + Xor, + // Relational + EqZ, + Eq, + Ne, + LtS, + LtU, + LeS, + LeU, + GtS, + GtU, + GeS, + GeU +}; + +inline bool hasAnyShift(BinaryOp op) { + return op == ShlInt32 || op == ShrSInt32 || op == ShrUInt32 || + op == RotLInt32 || op == RotRInt32 || op == ShlInt64 || + op == ShrSInt64 || op == ShrUInt64 || op == RotLInt64 || + op == RotRInt64; +} + +// Provide a wasm type and an abstract op and get the concrete one. For example, +// you can provide i32 and Add and receive the specific opcode for a 32-bit +// addition, AddInt32. If the op does not exist, it returns Invalid. +inline UnaryOp getUnary(Type type, Op op) { + switch (type.getBasic()) { + case Type::i32: { + switch (op) { + case EqZ: + return EqZInt32; + default: + return InvalidUnary; + } + break; + } + case Type::i64: { + switch (op) { + case EqZ: + return EqZInt64; + default: + return InvalidUnary; + } + break; + } + case Type::f32: { + switch (op) { + case Neg: + return NegFloat32; + default: + return InvalidUnary; + } + break; + } + case Type::f64: { + switch (op) { + case Neg: + return NegFloat64; + default: + return InvalidUnary; + } + break; + } + case Type::v128: + case Type::funcref: + case Type::externref: + case Type::exnref: + case Type::anyref: + case Type::eqref: + case Type::i31ref: + case Type::none: + case Type::unreachable: { + return InvalidUnary; + } + } + WASM_UNREACHABLE("invalid type"); +} + +inline BinaryOp getBinary(Type type, Op op) { + switch (type.getBasic()) { + case Type::i32: { + switch (op) { + case Add: + return AddInt32; + case Sub: + return SubInt32; + case Mul: + return MulInt32; + case DivU: + return DivUInt32; + case DivS: + return DivSInt32; + case RemU: + return RemUInt32; + case RemS: + return RemSInt32; + case Shl: + return ShlInt32; + case ShrU: + return ShrUInt32; + case ShrS: + return ShrSInt32; + case RotL: + return RotLInt32; + case RotR: + return RotRInt32; + case And: + return AndInt32; + case Or: + return OrInt32; + case Xor: + return XorInt32; + case Eq: + return EqInt32; + case Ne: + return NeInt32; + case LtS: + return LtSInt32; + case LtU: + return LtUInt32; + case LeS: + return LeSInt32; + case LeU: + return LeUInt32; + case GtS: + return GtSInt32; + case GtU: + return GtUInt32; + case GeS: + return GeSInt32; + case GeU: + return GeUInt32; + default: + return InvalidBinary; + } + break; + } + case Type::i64: { + switch (op) { + case Add: + return AddInt64; + case Sub: + return SubInt64; + case Mul: + return MulInt64; + case DivU: + return DivUInt64; + case DivS: + return DivSInt64; + case RemU: + return RemUInt64; + case RemS: + return RemSInt64; + case Shl: + return ShlInt64; + case ShrU: + return ShrUInt64; + case ShrS: + return ShrSInt64; + case RotL: + return RotLInt64; + case RotR: + return RotRInt64; + case And: + return AndInt64; + case Or: + return OrInt64; + case Xor: + return XorInt64; + case Eq: + return EqInt64; + case Ne: + return NeInt64; + case LtS: + return LtSInt64; + case LtU: + return LtUInt64; + case LeS: + return LeSInt64; + case LeU: + return LeUInt64; + case GtS: + return GtSInt64; + case GtU: + return GtUInt64; + case GeS: + return GeSInt64; + case GeU: + return GeUInt64; + default: + return InvalidBinary; + } + break; + } + case Type::f32: { + switch (op) { + case Add: + return AddFloat32; + case Sub: + return SubFloat32; + case Mul: + return MulFloat32; + case DivU: + return DivFloat32; + case DivS: + return DivFloat32; + case Eq: + return EqFloat32; + case Ne: + return NeFloat32; + default: + return InvalidBinary; + } + break; + } + case Type::f64: { + switch (op) { + case Add: + return AddFloat64; + case Sub: + return SubFloat64; + case Mul: + return MulFloat64; + case DivU: + return DivFloat64; + case DivS: + return DivFloat64; + case Eq: + return EqFloat64; + case Ne: + return NeFloat64; + default: + return InvalidBinary; + } + break; + } + case Type::v128: + case Type::funcref: + case Type::externref: + case Type::exnref: + case Type::anyref: + case Type::eqref: + case Type::i31ref: + case Type::none: + case Type::unreachable: { + return InvalidBinary; + } + } + WASM_UNREACHABLE("invalid type"); +} + +} // namespace Abstract + +} // namespace wasm + +#endif // wasm_ir_abstract_h diff --git a/binaryen/src/ir/bits.h b/binaryen/src/ir/bits.h new file mode 100644 --- /dev/null +++ b/binaryen/src/ir/bits.h @@ -0,0 +1,423 @@ +/* + * Copyright 2017 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef wasm_ir_bits_h +#define wasm_ir_bits_h + +#include "ir/literal-utils.h" +#include "support/bits.h" +#include "wasm-builder.h" +#include + +namespace wasm { + +namespace Bits { + +// get a mask to keep only the low # of bits +inline int32_t lowBitMask(int32_t bits) { + uint32_t ret = -1; + if (bits >= 32) { + return ret; + } + return ret >> (32 - bits); +} + +// checks if the input is a mask of lower bits, i.e., all 1s up to some high +// bit, and all zeros from there. returns the number of masked bits, or 0 if +// this is not such a mask +inline uint32_t getMaskedBits(uint32_t mask) { + if (mask == uint32_t(-1)) { + return 32; // all the bits + } + if (mask == 0) { + return 0; // trivially not a mask + } + // otherwise, see if x & (x + 1) turns this into non-zero value + // 00011111 & (00011111 + 1) => 0 + if (mask & (mask + 1)) { + return 0; + } + // this is indeed a mask + return 32 - countLeadingZeroes(mask); +} + +// gets the number of effective shifts a shift operation does. In +// wasm, only 5 bits matter for 32-bit shifts, and 6 for 64. +inline Index getEffectiveShifts(Index amount, Type type) { + if (type == Type::i32) { + return amount & 31; + } else if (type == Type::i64) { + return amount & 63; + } + WASM_UNREACHABLE("unexpected type"); +} + +inline Index getEffectiveShifts(Expression* expr) { + auto* amount = expr->cast(); + if (amount->type == Type::i32) { + return getEffectiveShifts(amount->value.geti32(), Type::i32); + } else if (amount->type == Type::i64) { + return getEffectiveShifts(amount->value.geti64(), Type::i64); + } + WASM_UNREACHABLE("unexpected type"); +} + +inline Expression* makeSignExt(Expression* value, Index bytes, Module& wasm) { + if (value->type == Type::i32) { + if (bytes == 1 || bytes == 2) { + auto shifts = bytes == 1 ? 24 : 16; + Builder builder(wasm); + return builder.makeBinary( + ShrSInt32, + builder.makeBinary( + ShlInt32, + value, + LiteralUtils::makeFromInt32(shifts, Type::i32, wasm)), + LiteralUtils::makeFromInt32(shifts, Type::i32, wasm)); + } + assert(bytes == 4); + return value; // nothing to do + } else { + assert(value->type == Type::i64); + if (bytes == 1 || bytes == 2 || bytes == 4) { + auto shifts = bytes == 1 ? 56 : (bytes == 2 ? 48 : 32); + Builder builder(wasm); + return builder.makeBinary( + ShrSInt64, + builder.makeBinary( + ShlInt64, + value, + LiteralUtils::makeFromInt32(shifts, Type::i64, wasm)), + LiteralUtils::makeFromInt32(shifts, Type::i64, wasm)); + } + assert(bytes == 8); + return value; // nothing to do + } +} + +// getMaxBits() helper that has pessimistic results for the bits used in locals. +struct DummyLocalInfoProvider { + Index getMaxBitsForLocal(LocalGet* get) { + if (get->type == Type::i32) { + return 32; + } else if (get->type == Type::i64) { + return 64; + } + WASM_UNREACHABLE("type has no integer bit size"); + } +}; + +// Returns the maximum amount of bits used in an integer expression +// not extremely precise (doesn't look into add operands, etc.) +// LocalInfoProvider is an optional class that can provide answers about +// local.get. +template +Index getMaxBits(Expression* curr, + LocalInfoProvider* localInfoProvider = nullptr) { + if (auto* c = curr->dynCast()) { + switch (curr->type.getBasic()) { + case Type::i32: + return 32 - c->value.countLeadingZeroes().geti32(); + case Type::i64: + return 64 - c->value.countLeadingZeroes().geti64(); + default: + WASM_UNREACHABLE("invalid type"); + } + } else if (auto* binary = curr->dynCast()) { + switch (binary->op) { + // 32-bit + case RotLInt32: + case RotRInt32: + case SubInt32: + return 32; + case AddInt32: { + auto maxBitsLeft = getMaxBits(binary->left, localInfoProvider); + auto maxBitsRight = getMaxBits(binary->right, localInfoProvider); + return std::min(Index(32), std::max(maxBitsLeft, maxBitsRight) + 1); + } + case MulInt32: { + auto maxBitsRight = getMaxBits(binary->right, localInfoProvider); + auto maxBitsLeft = getMaxBits(binary->left, localInfoProvider); + return std::min(Index(32), maxBitsLeft + maxBitsRight); + } + case DivSInt32: { + if (auto* c = binary->right->dynCast()) { + int32_t maxBitsLeft = getMaxBits(binary->left, localInfoProvider); + // If either side might be negative, then the result will be negative + if (maxBitsLeft == 32 || c->value.geti32() < 0) { + return 32; + } + int32_t bitsRight = getMaxBits(c); + return std::max(0, maxBitsLeft - bitsRight + 1); + } + return 32; + } + case DivUInt32: { + int32_t maxBitsLeft = getMaxBits(binary->left, localInfoProvider); + if (auto* c = binary->right->dynCast()) { + int32_t bitsRight = getMaxBits(c); + return std::max(0, maxBitsLeft - bitsRight + 1); + } + return maxBitsLeft; + } + case RemSInt32: { + if (auto* c = binary->right->dynCast()) { + auto maxBitsLeft = getMaxBits(binary->left, localInfoProvider); + // if left may be negative, the result may be negative + if (maxBitsLeft == 32) { + return 32; + } + auto bitsRight = Index(ceilLog2(c->value.geti32())); + return std::min(maxBitsLeft, bitsRight); + } + return 32; + } + case RemUInt32: { + if (auto* c = binary->right->dynCast()) { + auto maxBitsLeft = getMaxBits(binary->left, localInfoProvider); + auto bitsRight = Index(ceilLog2(c->value.geti32())); + return std::min(maxBitsLeft, bitsRight); + } + return 32; + } + case AndInt32: { + return std::min(getMaxBits(binary->left, localInfoProvider), + getMaxBits(binary->right, localInfoProvider)); + } + case OrInt32: + case XorInt32: { + return std::max(getMaxBits(binary->left, localInfoProvider), + getMaxBits(binary->right, localInfoProvider)); + } + case ShlInt32: { + if (auto* shifts = binary->right->dynCast()) { + return std::min(Index(32), + getMaxBits(binary->left, localInfoProvider) + + Bits::getEffectiveShifts(shifts)); + } + return 32; + } + case ShrUInt32: { + if (auto* shift = binary->right->dynCast()) { + auto maxBits = getMaxBits(binary->left, localInfoProvider); + auto shifts = + std::min(Index(Bits::getEffectiveShifts(shift)), + maxBits); // can ignore more shifts than zero us out + return std::max(Index(0), maxBits - shifts); + } + return 32; + } + case ShrSInt32: { + if (auto* shift = binary->right->dynCast()) { + auto maxBits = getMaxBits(binary->left, localInfoProvider); + // if left may be negative, the result may be negative + if (maxBits == 32) { + return 32; + } + auto shifts = + std::min(Index(Bits::getEffectiveShifts(shift)), + maxBits); // can ignore more shifts than zero us out + return std::max(Index(0), maxBits - shifts); + } + return 32; + } + case RotLInt64: + case RotRInt64: + case SubInt64: + return 64; + case AddInt64: { + auto maxBitsLeft = getMaxBits(binary->left, localInfoProvider); + auto maxBitsRight = getMaxBits(binary->right, localInfoProvider); + return std::min(Index(64), std::max(maxBitsLeft, maxBitsRight) + 1); + } + case MulInt64: { + auto maxBitsRight = getMaxBits(binary->right, localInfoProvider); + auto maxBitsLeft = getMaxBits(binary->left, localInfoProvider); + return std::min(Index(64), maxBitsLeft + maxBitsRight); + } + case DivSInt64: { + if (auto* c = binary->right->dynCast()) { + int32_t maxBitsLeft = getMaxBits(binary->left, localInfoProvider); + // if left or right const value is negative + if (maxBitsLeft == 64 || c->value.geti64() < 0) { + return 64; + } + int32_t bitsRight = getMaxBits(c); + return std::max(0, maxBitsLeft - bitsRight + 1); + } + return 64; + } + case DivUInt64: { + int32_t maxBitsLeft = getMaxBits(binary->left, localInfoProvider); + if (auto* c = binary->right->dynCast()) { + int32_t bitsRight = getMaxBits(c); + return std::max(0, maxBitsLeft - bitsRight + 1); + } + return maxBitsLeft; + } + case RemSInt64: { + if (auto* c = binary->right->dynCast()) { + auto maxBitsLeft = getMaxBits(binary->left, localInfoProvider); + // if left may be negative, the result may be negative + if (maxBitsLeft == 64) { + return 64; + } + auto bitsRight = Index(ceilLog2(c->value.geti64())); + return std::min(maxBitsLeft, bitsRight); + } + return 64; + } + case RemUInt64: { + if (auto* c = binary->right->dynCast()) { + auto maxBitsLeft = getMaxBits(binary->left, localInfoProvider); + auto bitsRight = Index(ceilLog2(c->value.geti64())); + return std::min(maxBitsLeft, bitsRight); + } + return 64; + } + case AndInt64: { + return std::min(getMaxBits(binary->left, localInfoProvider), + getMaxBits(binary->right, localInfoProvider)); + } + case OrInt64: + case XorInt64: { + return std::max(getMaxBits(binary->left, localInfoProvider), + getMaxBits(binary->right, localInfoProvider)); + } + case ShlInt64: { + if (auto* shifts = binary->right->dynCast()) { + auto maxBits = getMaxBits(binary->left, localInfoProvider); + return std::min(Index(64), + Bits::getEffectiveShifts(shifts) + maxBits); + } + return 64; + } + case ShrUInt64: { + if (auto* shift = binary->right->dynCast()) { + auto maxBits = getMaxBits(binary->left, localInfoProvider); + auto shifts = + std::min(Index(Bits::getEffectiveShifts(shift)), + maxBits); // can ignore more shifts than zero us out + return std::max(Index(0), maxBits - shifts); + } + return 64; + } + case ShrSInt64: { + if (auto* shift = binary->right->dynCast()) { + auto maxBits = getMaxBits(binary->left, localInfoProvider); + // if left may be negative, the result may be negative + if (maxBits == 64) { + return 64; + } + auto shifts = + std::min(Index(Bits::getEffectiveShifts(shift)), + maxBits); // can ignore more shifts than zero us out + return std::max(Index(0), maxBits - shifts); + } + return 64; + } + // comparisons + case EqInt32: + case NeInt32: + case LtSInt32: + case LtUInt32: + case LeSInt32: + case LeUInt32: + case GtSInt32: + case GtUInt32: + case GeSInt32: + case GeUInt32: + + case EqInt64: + case NeInt64: + case LtSInt64: + case LtUInt64: + case LeSInt64: + case LeUInt64: + case GtSInt64: + case GtUInt64: + case GeSInt64: + case GeUInt64: + + case EqFloat32: + case NeFloat32: + case LtFloat32: + case LeFloat32: + case GtFloat32: + case GeFloat32: + + case EqFloat64: + case NeFloat64: + case LtFloat64: + case LeFloat64: + case GtFloat64: + case GeFloat64: + return 1; + default: { + } + } + } else if (auto* unary = curr->dynCast()) { + switch (unary->op) { + case ClzInt32: + case CtzInt32: + case PopcntInt32: + return 6; + case ClzInt64: + case CtzInt64: + case PopcntInt64: + return 7; + case EqZInt32: + case EqZInt64: + return 1; + case WrapInt64: + case ExtendUInt32: + return std::min(Index(32), getMaxBits(unary->value, localInfoProvider)); + case ExtendSInt32: { + auto maxBits = getMaxBits(unary->value, localInfoProvider); + return maxBits == 32 ? Index(64) : maxBits; + } + default: { + } + } + } else if (auto* set = curr->dynCast()) { + // a tee passes through the value + return getMaxBits(set->value, localInfoProvider); + } else if (auto* get = curr->dynCast()) { + return localInfoProvider->getMaxBitsForLocal(get); + } else if (auto* load = curr->dynCast()) { + // if signed, then the sign-extension might fill all the bits + // if unsigned, then we have a limit + if (LoadUtils::isSignRelevant(load) && !load->signed_) { + return 8 * load->bytes; + } + } + switch (curr->type.getBasic()) { + case Type::i32: + return 32; + case Type::i64: + return 64; + case Type::unreachable: + return 64; // not interesting, but don't crash + default: + WASM_UNREACHABLE("invalid type"); + } +} + +} // namespace Bits + +} // namespace wasm + +#endif // wasm_ir_bits_h diff --git a/binaryen/src/ir/block-utils.h b/binaryen/src/ir/block-utils.h new file mode 100644 --- /dev/null +++ b/binaryen/src/ir/block-utils.h @@ -0,0 +1,76 @@ +/* + * Copyright 2017 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef wasm_ir_block_h +#define wasm_ir_block_h + +#include "ir/branch-utils.h" +#include "ir/effects.h" +#include "ir/manipulation.h" +#include "literal.h" +#include "wasm-builder.h" +#include "wasm.h" + +namespace wasm { + +namespace BlockUtils { +// if a block has just one element, it can often be replaced +// with that content +template +inline Expression* +simplifyToContents(Block* block, T* parent, bool allowTypeChange = false) { + auto& list = block->list; + if (list.size() == 1 && + !BranchUtils::BranchSeeker::has(list[0], block->name)) { + // just one element. try to replace the block + auto* singleton = list[0]; + auto sideEffects = EffectAnalyzer(parent->getPassOptions(), + parent->getModule()->features, + singleton) + .hasSideEffects(); + if (!sideEffects && !singleton->type.isConcrete()) { + // no side effects, and singleton is not returning a value, so we can + // throw away the block and its contents, basically + return Builder(*parent->getModule()).replaceWithIdenticalType(block); + } else if (Type::isSubType(singleton->type, block->type) || + allowTypeChange) { + return singleton; + } else { + // (side effects +) type change, must be block with declared value but + // inside is unreachable (if both concrete, must match, and since no name + // on block, we can't be branched to, so if singleton is unreachable, so + // is the block) + assert(block->type.isConcrete() && singleton->type == Type::unreachable); + // we could replace with unreachable, but would need to update all + // the parent's types + } + } else if (list.size() == 0) { + ExpressionManipulator::nop(block); + } + return block; +} + +// similar, but when we allow the type to change while doing so +template +inline Expression* simplifyToContentsWithPossibleTypeChange(Block* block, + T* parent) { + return simplifyToContents(block, parent, true); +} +} // namespace BlockUtils + +} // namespace wasm + +#endif // wasm_ir_block_h diff --git a/binaryen/src/ir/branch-utils.h b/binaryen/src/ir/branch-utils.h new file mode 100644 --- /dev/null +++ b/binaryen/src/ir/branch-utils.h @@ -0,0 +1,311 @@ +/* + * Copyright 2017 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef wasm_ir_branch_h +#define wasm_ir_branch_h + +#include "ir/iteration.h" +#include "wasm-traversal.h" +#include "wasm.h" + +namespace wasm { + +namespace BranchUtils { + +// Some branches are obviously not actually reachable (e.g. (br $out +// (unreachable))) + +inline bool isBranchReachable(Break* br) { + return !(br->value && br->value->type == Type::unreachable) && + !(br->condition && br->condition->type == Type::unreachable); +} + +inline bool isBranchReachable(Switch* sw) { + return !(sw->value && sw->value->type == Type::unreachable) && + sw->condition->type != Type::unreachable; +} + +inline bool isBranchReachable(BrOnExn* br) { + return br->exnref->type != Type::unreachable; +} + +inline bool isBranchReachable(Expression* expr) { + if (auto* br = expr->dynCast()) { + return isBranchReachable(br); + } else if (auto* sw = expr->dynCast()) { + return isBranchReachable(sw); + } else if (auto* br = expr->dynCast()) { + return isBranchReachable(br); + } + WASM_UNREACHABLE("unexpected expression type"); +} + +using NameSet = std::set; + +inline NameSet getUniqueTargets(Break* br) { return {br->name}; } + +inline NameSet getUniqueTargets(Switch* sw) { + NameSet ret; + for (auto target : sw->targets) { + ret.insert(target); + } + ret.insert(sw->default_); + return ret; +} + +inline NameSet getUniqueTargets(BrOnExn* br) { return {br->name}; } + +inline NameSet getUniqueTargets(Expression* expr) { + if (auto* br = expr->dynCast()) { + return getUniqueTargets(br); + } + if (auto* br = expr->dynCast()) { + return getUniqueTargets(br); + } + if (auto* br = expr->dynCast()) { + return getUniqueTargets(br); + } + return {}; +} +// If we branch to 'from', change that to 'to' instead. +inline bool replacePossibleTarget(Expression* branch, Name from, Name to) { + bool worked = false; + if (auto* br = branch->dynCast()) { + if (br->name == from) { + br->name = to; + worked = true; + } + } else if (auto* sw = branch->dynCast()) { + for (auto& target : sw->targets) { + if (target == from) { + target = to; + worked = true; + } + } + if (sw->default_ == from) { + sw->default_ = to; + worked = true; + } + } else if (auto* br = branch->dynCast()) { + if (br->name == from) { + br->name = to; + worked = true; + } + } else { + WASM_UNREACHABLE("unexpected expression type"); + } + return worked; +} + +// returns the set of targets to which we branch that are +// outside of a node +inline NameSet getExitingBranches(Expression* ast) { + struct Scanner : public PostWalker { + NameSet targets; + + void visitBreak(Break* curr) { targets.insert(curr->name); } + void visitSwitch(Switch* curr) { + for (auto target : curr->targets) { + targets.insert(target); + } + targets.insert(curr->default_); + } + void visitBrOnExn(BrOnExn* curr) { targets.insert(curr->name); } + void visitBlock(Block* curr) { + if (curr->name.is()) { + targets.erase(curr->name); + } + } + void visitLoop(Loop* curr) { + if (curr->name.is()) { + targets.erase(curr->name); + } + } + }; + Scanner scanner; + scanner.walk(ast); + // anything not erased is a branch out + return scanner.targets; +} + +// returns the list of all branch targets in a node + +inline NameSet getBranchTargets(Expression* ast) { + struct Scanner : public PostWalker { + NameSet targets; + + void visitBlock(Block* curr) { + if (curr->name.is()) { + targets.insert(curr->name); + } + } + void visitLoop(Loop* curr) { + if (curr->name.is()) { + targets.insert(curr->name); + } + } + }; + Scanner scanner; + scanner.walk(ast); + return scanner.targets; +} + +// Finds if there are branches targeting a name. Note that since names are +// unique in our IR, we just need to look for the name, and do not need +// to analyze scoping. +struct BranchSeeker : public PostWalker { + Name target; + + Index found = 0; + Type valueType; + + BranchSeeker(Name target) : target(target) {} + + void noteFound(Expression* value) { + noteFound(value ? value->type : Type::none); + } + + void noteFound(Type type) { + found++; + if (found == 1) { + valueType = Type::unreachable; + } + if (type != Type::unreachable) { + valueType = type; + } + } + + void visitBreak(Break* curr) { + // check the break + if (curr->name == target) { + noteFound(curr->value); + } + } + + void visitSwitch(Switch* curr) { + // check the switch + for (auto name : curr->targets) { + if (name == target) { + noteFound(curr->value); + } + } + if (curr->default_ == target) { + noteFound(curr->value); + } + } + + void visitBrOnExn(BrOnExn* curr) { + // check the br_on_exn + if (curr->name == target) { + noteFound(curr->sent); + } + } + + static bool has(Expression* tree, Name target) { + if (!target.is()) { + return false; + } + BranchSeeker seeker(target); + seeker.walk(tree); + return seeker.found > 0; + } + + static Index count(Expression* tree, Name target) { + if (!target.is()) { + return 0; + } + BranchSeeker seeker(target); + seeker.walk(tree); + return seeker.found; + } +}; + +// Accumulates all the branches in an entire tree. +struct BranchAccumulator + : public PostWalker> { + NameSet branches; + + void visitExpression(Expression* curr) { + auto selfBranches = getUniqueTargets(curr); + branches.insert(selfBranches.begin(), selfBranches.end()); + } +}; + +// A helper structure for the common case of post-walking some IR while querying +// whether a branch is present. We can cache results for children in order to +// avoid quadratic time searches. +// We assume that a node will be scanned *once* here. That means that if we +// scan a node, we can discard all information for its children. This avoids +// linearly increasing memory usage over time. +class BranchSeekerCache { + // Maps all the branches present in an expression and all its nested children. + std::unordered_map branches; + +public: + const NameSet& getBranches(Expression* curr) { + auto iter = branches.find(curr); + if (iter != branches.end()) { + return iter->second; + } + NameSet currBranches; + auto add = [&](NameSet& moreBranches) { + // Make sure to do a fast swap for the first set of branches to arrive. + // This helps the case of the first child being a block with a very large + // set of names. + if (currBranches.empty()) { + currBranches.swap(moreBranches); + } else { + currBranches.insert(moreBranches.begin(), moreBranches.end()); + } + }; + // Add from the children, which are hopefully cached. + for (auto child : ChildIterator(curr)) { + auto iter = branches.find(child); + if (iter != branches.end()) { + add(iter->second); + // We are scanning the parent, which means we assume the child will + // never be visited again. + branches.erase(iter); + } else { + // The child was not cached. Scan it manually. + BranchAccumulator childBranches; + childBranches.walk(child); + add(childBranches.branches); + // Don't bother caching anything - we are scanning the parent, so the + // child will presumably not be scanned again. + } + } + // Finish with the parent's own branches. + auto selfBranches = getUniqueTargets(curr); + add(selfBranches); + return branches[curr] = std::move(currBranches); + } + + bool hasBranch(Expression* curr, Name target) { + bool result = getBranches(curr).count(target); +#ifdef BRANCH_UTILS_DEBUG + assert(bresult == BranchSeeker::has(curr, target)); +#endif + return result; + } +}; + +} // namespace BranchUtils + +} // namespace wasm + +#endif // wasm_ir_branch_h diff --git a/binaryen/src/ir/cost.h b/binaryen/src/ir/cost.h new file mode 100644 --- /dev/null +++ b/binaryen/src/ir/cost.h @@ -0,0 +1,780 @@ +/* + * Copyright 2016 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef wasm_ir_cost_h +#define wasm_ir_cost_h + +#include +#include + +namespace wasm { + +// Measure the execution cost of an AST. Very handwave-ey + +struct CostAnalyzer : public Visitor { + CostAnalyzer(Expression* ast) { cost = visit(ast); } + + Index cost; + + Index maybeVisit(Expression* curr) { return curr ? visit(curr) : 0; } + + Index visitBlock(Block* curr) { + Index ret = 0; + for (auto* child : curr->list) { + ret += visit(child); + } + return ret; + } + Index visitIf(If* curr) { + return 1 + visit(curr->condition) + + std::max(visit(curr->ifTrue), maybeVisit(curr->ifFalse)); + } + Index visitLoop(Loop* curr) { return 5 * visit(curr->body); } + Index visitBreak(Break* curr) { + return 1 + maybeVisit(curr->value) + maybeVisit(curr->condition); + } + Index visitSwitch(Switch* curr) { + return 2 + visit(curr->condition) + maybeVisit(curr->value); + } + Index visitCall(Call* curr) { + // XXX this does not take into account if the call is to an import, which + // may be costlier in general + Index ret = 4; + for (auto* child : curr->operands) { + ret += visit(child); + } + return ret; + } + Index visitCallIndirect(CallIndirect* curr) { + Index ret = 6 + visit(curr->target); + for (auto* child : curr->operands) { + ret += visit(child); + } + return ret; + } + Index visitLocalGet(LocalGet* curr) { return 0; } + Index visitLocalSet(LocalSet* curr) { return 1; } + Index visitGlobalGet(GlobalGet* curr) { return 1; } + Index visitGlobalSet(GlobalSet* curr) { return 2; } + Index visitLoad(Load* curr) { + return 1 + visit(curr->ptr) + 10 * curr->isAtomic; + } + Index visitStore(Store* curr) { + return 2 + visit(curr->ptr) + visit(curr->value) + 10 * curr->isAtomic; + } + Index visitAtomicRMW(AtomicRMW* curr) { return 100; } + Index visitAtomicCmpxchg(AtomicCmpxchg* curr) { return 100; } + Index visitConst(Const* curr) { return 1; } + Index visitUnary(Unary* curr) { + Index ret = 0; + switch (curr->op) { + case ClzInt32: + case CtzInt32: + case PopcntInt32: + case NegFloat32: + case AbsFloat32: + case CeilFloat32: + case FloorFloat32: + case TruncFloat32: + case NearestFloat32: + case ClzInt64: + case CtzInt64: + case PopcntInt64: + case NegFloat64: + case AbsFloat64: + case CeilFloat64: + case FloorFloat64: + case TruncFloat64: + case NearestFloat64: + case EqZInt32: + case EqZInt64: + case ExtendSInt32: + case ExtendUInt32: + case WrapInt64: + case PromoteFloat32: + case DemoteFloat64: + case TruncSFloat32ToInt32: + case TruncUFloat32ToInt32: + case TruncSFloat64ToInt32: + case TruncUFloat64ToInt32: + case ReinterpretFloat32: + case TruncSFloat32ToInt64: + case TruncUFloat32ToInt64: + case TruncSFloat64ToInt64: + case TruncUFloat64ToInt64: + case ReinterpretFloat64: + case ReinterpretInt32: + case ConvertSInt32ToFloat32: + case ConvertUInt32ToFloat32: + case ConvertSInt64ToFloat32: + case ConvertUInt64ToFloat32: + case ReinterpretInt64: + case ConvertSInt32ToFloat64: + case ConvertUInt32ToFloat64: + case ConvertSInt64ToFloat64: + case ConvertUInt64ToFloat64: + case ExtendS8Int32: + case ExtendS16Int32: + case ExtendS8Int64: + case ExtendS16Int64: + case ExtendS32Int64: + case TruncSatSFloat32ToInt32: + case TruncSatUFloat32ToInt32: + case TruncSatSFloat64ToInt32: + case TruncSatUFloat64ToInt32: + case TruncSatSFloat32ToInt64: + case TruncSatUFloat32ToInt64: + case TruncSatSFloat64ToInt64: + case TruncSatUFloat64ToInt64: + ret = 1; + break; + case SqrtFloat32: + case SqrtFloat64: + ret = 2; + break; + case SplatVecI8x16: + case SplatVecI16x8: + case SplatVecI32x4: + case SplatVecI64x2: + case SplatVecF32x4: + case SplatVecF64x2: + case NotVec128: + case AbsVecI8x16: + case NegVecI8x16: + case AnyTrueVecI8x16: + case AllTrueVecI8x16: + case BitmaskVecI8x16: + case AbsVecI16x8: + case NegVecI16x8: + case AnyTrueVecI16x8: + case AllTrueVecI16x8: + case BitmaskVecI16x8: + case AbsVecI32x4: + case NegVecI32x4: + case AnyTrueVecI32x4: + case AllTrueVecI32x4: + case BitmaskVecI32x4: + case NegVecI64x2: + case AnyTrueVecI64x2: + case AllTrueVecI64x2: + case AbsVecF32x4: + case NegVecF32x4: + case SqrtVecF32x4: + case CeilVecF32x4: + case FloorVecF32x4: + case TruncVecF32x4: + case NearestVecF32x4: + case AbsVecF64x2: + case NegVecF64x2: + case SqrtVecF64x2: + case CeilVecF64x2: + case FloorVecF64x2: + case TruncVecF64x2: + case NearestVecF64x2: + case TruncSatSVecF32x4ToVecI32x4: + case TruncSatUVecF32x4ToVecI32x4: + case TruncSatSVecF64x2ToVecI64x2: + case TruncSatUVecF64x2ToVecI64x2: + case ConvertSVecI32x4ToVecF32x4: + case ConvertUVecI32x4ToVecF32x4: + case ConvertSVecI64x2ToVecF64x2: + case ConvertUVecI64x2ToVecF64x2: + case WidenLowSVecI8x16ToVecI16x8: + case WidenHighSVecI8x16ToVecI16x8: + case WidenLowUVecI8x16ToVecI16x8: + case WidenHighUVecI8x16ToVecI16x8: + case WidenLowSVecI16x8ToVecI32x4: + case WidenHighSVecI16x8ToVecI32x4: + case WidenLowUVecI16x8ToVecI32x4: + case WidenHighUVecI16x8ToVecI32x4: + return 1; + case InvalidUnary: + WASM_UNREACHABLE("invalid unary op"); + } + return ret + visit(curr->value); + } + Index visitBinary(Binary* curr) { + Index ret = 0; + switch (curr->op) { + case AddInt32: + ret = 1; + break; + case SubInt32: + ret = 1; + break; + case MulInt32: + ret = 2; + break; + case DivSInt32: + ret = 3; + break; + case DivUInt32: + ret = 3; + break; + case RemSInt32: + ret = 3; + break; + case RemUInt32: + ret = 3; + break; + case AndInt32: + ret = 1; + break; + case OrInt32: + ret = 1; + break; + case XorInt32: + ret = 1; + break; + case ShlInt32: + ret = 1; + break; + case ShrUInt32: + ret = 1; + break; + case ShrSInt32: + ret = 1; + break; + case RotLInt32: + ret = 1; + break; + case RotRInt32: + ret = 1; + break; + case AddInt64: + ret = 1; + break; + case SubInt64: + ret = 1; + break; + case MulInt64: + ret = 2; + break; + case DivSInt64: + ret = 3; + break; + case DivUInt64: + ret = 3; + break; + case RemSInt64: + ret = 3; + break; + case RemUInt64: + ret = 3; + break; + case AndInt64: + ret = 1; + break; + case OrInt64: + ret = 1; + break; + case XorInt64: + ret = 1; + break; + case ShlInt64: + ret = 1; + break; + case ShrUInt64: + ret = 1; + break; + case ShrSInt64: + ret = 1; + break; + case RotLInt64: + ret = 1; + break; + case RotRInt64: + ret = 1; + break; + case AddFloat32: + ret = 1; + break; + case SubFloat32: + ret = 1; + break; + case MulFloat32: + ret = 2; + break; + case DivFloat32: + ret = 3; + break; + case CopySignFloat32: + ret = 1; + break; + case MinFloat32: + ret = 1; + break; + case MaxFloat32: + ret = 1; + break; + case AddFloat64: + ret = 1; + break; + case SubFloat64: + ret = 1; + break; + case MulFloat64: + ret = 2; + break; + case DivFloat64: + ret = 3; + break; + case CopySignFloat64: + ret = 1; + break; + case MinFloat64: + ret = 1; + break; + case MaxFloat64: + ret = 1; + break; + case LtUInt32: + ret = 1; + break; + case LtSInt32: + ret = 1; + break; + case LeUInt32: + ret = 1; + break; + case LeSInt32: + ret = 1; + break; + case GtUInt32: + ret = 1; + break; + case GtSInt32: + ret = 1; + break; + case GeUInt32: + ret = 1; + break; + case GeSInt32: + ret = 1; + break; + case LtUInt64: + ret = 1; + break; + case LtSInt64: + ret = 1; + break; + case LeUInt64: + ret = 1; + break; + case LeSInt64: + ret = 1; + break; + case GtUInt64: + ret = 1; + break; + case GtSInt64: + ret = 1; + break; + case GeUInt64: + ret = 1; + break; + case GeSInt64: + ret = 1; + break; + case LtFloat32: + ret = 1; + break; + case GtFloat32: + ret = 1; + break; + case LeFloat32: + ret = 1; + break; + case GeFloat32: + ret = 1; + break; + case LtFloat64: + ret = 1; + break; + case GtFloat64: + ret = 1; + break; + case LeFloat64: + ret = 1; + break; + case GeFloat64: + ret = 1; + break; + case EqInt32: + ret = 1; + break; + case NeInt32: + ret = 1; + break; + case EqInt64: + ret = 1; + break; + case NeInt64: + ret = 1; + break; + case EqFloat32: + ret = 1; + break; + case NeFloat32: + ret = 1; + break; + case EqFloat64: + ret = 1; + break; + case NeFloat64: + ret = 1; + break; + case EqVecI8x16: + ret = 1; + break; + case NeVecI8x16: + ret = 1; + break; + case LtSVecI8x16: + ret = 1; + break; + case LtUVecI8x16: + ret = 1; + break; + case LeSVecI8x16: + ret = 1; + break; + case LeUVecI8x16: + ret = 1; + break; + case GtSVecI8x16: + ret = 1; + break; + case GtUVecI8x16: + ret = 1; + break; + case GeSVecI8x16: + ret = 1; + break; + case GeUVecI8x16: + ret = 1; + break; + case EqVecI16x8: + ret = 1; + break; + case NeVecI16x8: + ret = 1; + break; + case LtSVecI16x8: + ret = 1; + break; + case LtUVecI16x8: + ret = 1; + break; + case LeSVecI16x8: + ret = 1; + break; + case LeUVecI16x8: + ret = 1; + break; + case GtSVecI16x8: + ret = 1; + break; + case GtUVecI16x8: + ret = 1; + break; + case GeSVecI16x8: + ret = 1; + break; + case GeUVecI16x8: + ret = 1; + break; + case EqVecI32x4: + ret = 1; + break; + case NeVecI32x4: + ret = 1; + break; + case LtSVecI32x4: + ret = 1; + break; + case LtUVecI32x4: + ret = 1; + break; + case LeSVecI32x4: + ret = 1; + break; + case LeUVecI32x4: + ret = 1; + break; + case GtSVecI32x4: + ret = 1; + break; + case GtUVecI32x4: + ret = 1; + break; + case GeSVecI32x4: + ret = 1; + break; + case GeUVecI32x4: + ret = 1; + break; + case EqVecF32x4: + ret = 1; + break; + case NeVecF32x4: + ret = 1; + break; + case LtVecF32x4: + ret = 1; + break; + case LeVecF32x4: + ret = 1; + break; + case GtVecF32x4: + ret = 1; + break; + case GeVecF32x4: + ret = 1; + break; + case EqVecF64x2: + ret = 1; + break; + case NeVecF64x2: + ret = 1; + break; + case LtVecF64x2: + ret = 1; + break; + case LeVecF64x2: + ret = 1; + break; + case GtVecF64x2: + ret = 1; + break; + case GeVecF64x2: + ret = 1; + break; + case AndVec128: + ret = 1; + break; + case OrVec128: + ret = 1; + break; + case XorVec128: + ret = 1; + break; + case AndNotVec128: + ret = 1; + break; + case AddVecI8x16: + ret = 1; + break; + case AddSatSVecI8x16: + ret = 1; + break; + case AddSatUVecI8x16: + ret = 1; + break; + case SubVecI8x16: + ret = 1; + break; + case SubSatSVecI8x16: + ret = 1; + break; + case SubSatUVecI8x16: + ret = 1; + break; + case MulVecI8x16: + ret = 2; + break; + case MinSVecI8x16: + ret = 1; + break; + case MinUVecI8x16: + ret = 1; + break; + case MaxSVecI8x16: + ret = 1; + break; + case MaxUVecI8x16: + ret = 1; + break; + case AvgrUVecI8x16: + ret = 1; + break; + case AddVecI16x8: + ret = 1; + break; + case AddSatSVecI16x8: + ret = 1; + break; + case AddSatUVecI16x8: + ret = 1; + break; + case SubVecI16x8: + ret = 1; + break; + case SubSatSVecI16x8: + ret = 1; + break; + case SubSatUVecI16x8: + ret = 1; + break; + case MulVecI16x8: + ret = 2; + break; + case MinSVecI16x8: + ret = 1; + break; + case MinUVecI16x8: + ret = 1; + break; + case MaxSVecI16x8: + ret = 1; + break; + case MaxUVecI16x8: + ret = 1; + break; + case AvgrUVecI16x8: + ret = 1; + break; + case AddVecI32x4: + ret = 1; + break; + case SubVecI32x4: + ret = 1; + break; + case MulVecI32x4: + ret = 2; + break; + case MinSVecI32x4: + ret = 1; + break; + case MinUVecI32x4: + ret = 1; + break; + case MaxSVecI32x4: + ret = 1; + break; + case MaxUVecI32x4: + ret = 1; + break; + case DotSVecI16x8ToVecI32x4: + ret = 1; + break; + case AddVecI64x2: + ret = 1; + break; + case SubVecI64x2: + ret = 1; + break; + case MulVecI64x2: + ret = 1; + break; + case AddVecF32x4: + ret = 1; + break; + case SubVecF32x4: + ret = 1; + break; + case MulVecF32x4: + ret = 2; + break; + case DivVecF32x4: + ret = 3; + break; + case MinVecF32x4: + ret = 1; + break; + case MaxVecF32x4: + ret = 1; + break; + case PMinVecF32x4: + ret = 1; + break; + case PMaxVecF32x4: + ret = 1; + break; + case AddVecF64x2: + ret = 1; + break; + case SubVecF64x2: + ret = 1; + break; + case MulVecF64x2: + ret = 2; + break; + case DivVecF64x2: + ret = 3; + break; + case MinVecF64x2: + ret = 1; + break; + case MaxVecF64x2: + ret = 1; + break; + case PMinVecF64x2: + ret = 1; + break; + case PMaxVecF64x2: + ret = 1; + break; + case NarrowSVecI16x8ToVecI8x16: + ret = 1; + break; + case NarrowUVecI16x8ToVecI8x16: + ret = 1; + break; + case NarrowSVecI32x4ToVecI16x8: + ret = 1; + break; + case NarrowUVecI32x4ToVecI16x8: + ret = 1; + break; + case SwizzleVec8x16: + ret = 1; + break; + case InvalidBinary: + WASM_UNREACHABLE("invalid binary op"); + } + return ret + visit(curr->left) + visit(curr->right); + } + Index visitSelect(Select* curr) { + return 2 + visit(curr->condition) + visit(curr->ifTrue) + + visit(curr->ifFalse); + } + Index visitDrop(Drop* curr) { return visit(curr->value); } + Index visitReturn(Return* curr) { return maybeVisit(curr->value); } + Index visitMemorySize(MemorySize* curr) { return 1; } + Index visitMemoryGrow(MemoryGrow* curr) { return 100; } + Index visitRefNull(RefNull* curr) { return 1; } + Index visitRefIsNull(RefIsNull* curr) { return 1 + visit(curr->value); } + Index visitRefFunc(RefFunc* curr) { return 1; } + Index visitRefEq(RefEq* curr) { + return 1 + visit(curr->left) + visit(curr->right); + } + Index visitTry(Try* curr) { + // We assume no exception will be thrown in most cases + return visit(curr->body); + } + Index visitThrow(Throw* curr) { return 100; } + Index visitRethrow(Rethrow* curr) { return 100; } + Index visitBrOnExn(BrOnExn* curr) { + return 1 + visit(curr->exnref) + curr->sent.size(); + } + Index visitNop(Nop* curr) { return 0; } + Index visitUnreachable(Unreachable* curr) { return 0; } +}; + +} // namespace wasm + +#endif // wasm_ir_cost_h diff --git a/binaryen/src/ir/debug.h b/binaryen/src/ir/debug.h new file mode 100644 --- /dev/null +++ b/binaryen/src/ir/debug.h @@ -0,0 +1,59 @@ +/* + * Copyright 2019 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef wasm_ir_debug_h +#define wasm_ir_debug_h + +#include + +namespace wasm { + +namespace debug { + +// Given an expression and a copy of it in another function, copy the debug +// info into the second function. +inline void copyDebugInfo(Expression* origin, + Expression* copy, + Function* originFunc, + Function* copyFunc) { + struct Lister : public PostWalker> { + std::vector list; + void visitExpression(Expression* curr) { list.push_back(curr); } + }; + + Lister originList; + originList.walk(origin); + Lister copyList; + copyList.walk(copy); + + auto& originDebug = originFunc->debugLocations; + auto& copyDebug = copyFunc->debugLocations; + + assert(originList.list.size() == copyList.list.size()); + for (Index i = 0; i < originList.list.size(); i++) { + auto iter = originDebug.find(originList.list[i]); + if (iter != originDebug.end()) { + auto location = iter->second; + copyDebug[copyList.list[i]] = location; + } + } +}; + +} // namespace debug + +} // namespace wasm + +#endif // wasm_ir_debug_h diff --git a/binaryen/src/ir/effects.h b/binaryen/src/ir/effects.h new file mode 100644 --- /dev/null +++ b/binaryen/src/ir/effects.h @@ -0,0 +1,619 @@ +/* + * Copyright 2017 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef wasm_ir_effects_h +#define wasm_ir_effects_h + +#include "pass.h" +#include "wasm-traversal.h" + +namespace wasm { + +// Look for side effects, including control flow +// TODO: optimize + +struct EffectAnalyzer + : public PostWalker> { + EffectAnalyzer(const PassOptions& passOptions, + FeatureSet features, + Expression* ast = nullptr) + : ignoreImplicitTraps(passOptions.ignoreImplicitTraps), + debugInfo(passOptions.debugInfo), features(features) { + if (ast) { + analyze(ast); + } + } + + bool ignoreImplicitTraps; + bool debugInfo; + FeatureSet features; + + void analyze(Expression* ast) { + breakTargets.clear(); + walk(ast); + assert(tryDepth == 0); + } + + // Core effect tracking + + // Definitely branches out of this expression, or does a return, etc. + // breakTargets tracks individual targets, which we may eventually see are + // internal, while this is set when we see something that will definitely + // not be internal, or is otherwise special like an infinite loop (which + // does not technically branch "out", but it does break the normal assumption + // of control flow proceeding normally). + bool branchesOut = false; + bool calls = false; + std::set localsRead; + std::set localsWritten; + std::set globalsRead; + std::set globalsWritten; + bool readsMemory = false; + bool writesMemory = false; + // a load or div/rem, which may trap. we ignore trap differences, so it is ok + // to reorder these, but we can't remove them, as they count as side effects, + // and we can't move them in a way that would cause other noticeable (global) + // side effects + bool implicitTrap = false; + // An atomic load/store/RMW/Cmpxchg or an operator that has a defined ordering + // wrt atomics (e.g. memory.grow) + bool isAtomic = false; + bool throws = false; + // The nested depth of try. If an instruction that may throw is inside an + // inner try, we don't mark it as 'throws', because it will be caught by an + // inner catch. + size_t tryDepth = 0; + // The nested depth of catch. This is necessary to track danglng pops. + size_t catchDepth = 0; + // If this expression contains 'exnref.pop's that are not enclosed in 'catch' + // body. For example, (drop (exnref.pop)) should set this to true. + bool danglingPop = false; + + static void scan(EffectAnalyzer* self, Expression** currp) { + Expression* curr = *currp; + // We need to decrement try depth before catch starts, so handle it + // separately + if (curr->is()) { + self->pushTask(doVisitTry, currp); + self->pushTask(doEndCatch, currp); + self->pushTask(scan, &curr->cast()->catchBody); + self->pushTask(doStartCatch, currp); + self->pushTask(scan, &curr->cast()->body); + self->pushTask(doStartTry, currp); + return; + } + PostWalker>::scan(self, + currp); + } + + static void doStartTry(EffectAnalyzer* self, Expression** currp) { + self->tryDepth++; + } + + static void doStartCatch(EffectAnalyzer* self, Expression** currp) { + assert(self->tryDepth > 0 && "try depth cannot be negative"); + self->tryDepth--; + self->catchDepth++; + } + + static void doEndCatch(EffectAnalyzer* self, Expression** currp) { + assert(self->catchDepth > 0 && "catch depth cannot be negative"); + self->catchDepth--; + } + + // Helper functions to check for various effect types + + bool accessesLocal() const { + return localsRead.size() + localsWritten.size() > 0; + } + bool accessesGlobal() const { + return globalsRead.size() + globalsWritten.size() > 0; + } + bool accessesMemory() const { return calls || readsMemory || writesMemory; } + // Check whether this may transfer control flow to somewhere outside of this + // expression (aside from just flowing out normally). That includes a break + // or a throw (if the throw is not known to be caught inside this expression; + // note that if the throw is not caught in this expression then it might be + // caught in this function but outside of this expression, or it might not be + // caught in the function at all, which would mean control flow cannot be + // transferred inside the function, but this expression does not know that). + bool transfersControlFlow() const { + return branchesOut || throws || hasExternalBreakTargets(); + } + + bool hasGlobalSideEffects() const { + return calls || globalsWritten.size() > 0 || writesMemory || isAtomic || + throws; + } + bool hasSideEffects() const { + return hasGlobalSideEffects() || localsWritten.size() > 0 || + transfersControlFlow() || implicitTrap || danglingPop; + } + bool hasAnything() const { + return hasSideEffects() || accessesLocal() || readsMemory || + accessesGlobal() || isAtomic; + } + + bool noticesGlobalSideEffects() const { + return calls || readsMemory || isAtomic || globalsRead.size(); + } + + // check if we break to anything external from ourselves + bool hasExternalBreakTargets() const { return !breakTargets.empty(); } + + // checks if these effects would invalidate another set (e.g., if we write, we + // invalidate someone that reads, they can't be moved past us) + bool invalidates(const EffectAnalyzer& other) { + if ((transfersControlFlow() && other.hasSideEffects()) || + (other.transfersControlFlow() && hasSideEffects()) || + ((writesMemory || calls) && other.accessesMemory()) || + (accessesMemory() && (other.writesMemory || other.calls)) || + (danglingPop || other.danglingPop)) { + return true; + } + // All atomics are sequentially consistent for now, and ordered wrt other + // memory references. + if ((isAtomic && other.accessesMemory()) || + (other.isAtomic && accessesMemory())) { + return true; + } + for (auto local : localsWritten) { + if (other.localsWritten.count(local) || other.localsRead.count(local)) { + return true; + } + } + for (auto local : localsRead) { + if (other.localsWritten.count(local)) { + return true; + } + } + if ((accessesGlobal() && other.calls) || + (other.accessesGlobal() && calls)) { + return true; + } + for (auto global : globalsWritten) { + if (other.globalsWritten.count(global) || + other.globalsRead.count(global)) { + return true; + } + } + for (auto global : globalsRead) { + if (other.globalsWritten.count(global)) { + return true; + } + } + // we are ok to reorder implicit traps, but not conditionalize them + if ((implicitTrap && other.transfersControlFlow()) || + (other.implicitTrap && transfersControlFlow())) { + return true; + } + // we can't reorder an implicit trap in a way that alters global state + if ((implicitTrap && other.hasGlobalSideEffects()) || + (other.implicitTrap && hasGlobalSideEffects())) { + return true; + } + return false; + } + + void mergeIn(EffectAnalyzer& other) { + branchesOut = branchesOut || other.branchesOut; + calls = calls || other.calls; + readsMemory = readsMemory || other.readsMemory; + writesMemory = writesMemory || other.writesMemory; + implicitTrap = implicitTrap || other.implicitTrap; + isAtomic = isAtomic || other.isAtomic; + throws = throws || other.throws; + danglingPop = danglingPop || other.danglingPop; + for (auto i : other.localsRead) { + localsRead.insert(i); + } + for (auto i : other.localsWritten) { + localsWritten.insert(i); + } + for (auto i : other.globalsRead) { + globalsRead.insert(i); + } + for (auto i : other.globalsWritten) { + globalsWritten.insert(i); + } + for (auto i : other.breakTargets) { + breakTargets.insert(i); + } + } + + // the checks above happen after the node's children were processed, in the + // order of execution we must also check for control flow that happens before + // the children, i.e., loops + bool checkPre(Expression* curr) { + if (curr->is()) { + branchesOut = true; + return true; + } + return false; + } + + bool checkPost(Expression* curr) { + visit(curr); + if (curr->is()) { + branchesOut = true; + } + return hasAnything(); + } + + std::set breakTargets; + + void visitBlock(Block* curr) { + if (curr->name.is()) { + breakTargets.erase(curr->name); // these were internal breaks + } + } + void visitIf(If* curr) {} + void visitLoop(Loop* curr) { + if (curr->name.is()) { + breakTargets.erase(curr->name); // these were internal breaks + } + // if the loop is unreachable, then there is branching control flow: + // (1) if the body is unreachable because of a (return), uncaught (br) + // etc., then we already noted branching, so it is ok to mark it again + // (if we have *caught* (br)s, then they did not lead to the loop body + // being unreachable). (same logic applies to blocks) + // (2) if the loop is unreachable because it only has branches up to the + // loop top, but no way to get out, then it is an infinite loop, and we + // consider that a branching side effect (note how the same logic does + // not apply to blocks). + if (curr->type == Type::unreachable) { + branchesOut = true; + } + } + void visitBreak(Break* curr) { breakTargets.insert(curr->name); } + void visitSwitch(Switch* curr) { + for (auto name : curr->targets) { + breakTargets.insert(name); + } + breakTargets.insert(curr->default_); + } + + void visitCall(Call* curr) { + calls = true; + // When EH is enabled, any call can throw. + if (features.hasExceptionHandling() && tryDepth == 0) { + throws = true; + } + if (curr->isReturn) { + branchesOut = true; + } + if (debugInfo) { + // debugInfo call imports must be preserved very strongly, do not + // move code around them + // FIXME: we could check if the call is to an import + branchesOut = true; + } + } + void visitCallIndirect(CallIndirect* curr) { + calls = true; + if (features.hasExceptionHandling() && tryDepth == 0) { + throws = true; + } + if (curr->isReturn) { + branchesOut = true; + } + } + void visitLocalGet(LocalGet* curr) { localsRead.insert(curr->index); } + void visitLocalSet(LocalSet* curr) { localsWritten.insert(curr->index); } + void visitGlobalGet(GlobalGet* curr) { globalsRead.insert(curr->name); } + void visitGlobalSet(GlobalSet* curr) { globalsWritten.insert(curr->name); } + void visitLoad(Load* curr) { + readsMemory = true; + isAtomic |= curr->isAtomic; + if (!ignoreImplicitTraps) { + implicitTrap = true; + } + } + void visitStore(Store* curr) { + writesMemory = true; + isAtomic |= curr->isAtomic; + if (!ignoreImplicitTraps) { + implicitTrap = true; + } + } + void visitAtomicRMW(AtomicRMW* curr) { + readsMemory = true; + writesMemory = true; + isAtomic = true; + if (!ignoreImplicitTraps) { + implicitTrap = true; + } + } + void visitAtomicCmpxchg(AtomicCmpxchg* curr) { + readsMemory = true; + writesMemory = true; + isAtomic = true; + if (!ignoreImplicitTraps) { + implicitTrap = true; + } + } + void visitAtomicWait(AtomicWait* curr) { + readsMemory = true; + // AtomicWait doesn't strictly write memory, but it does modify the waiters + // list associated with the specified address, which we can think of as a + // write. + writesMemory = true; + isAtomic = true; + if (!ignoreImplicitTraps) { + implicitTrap = true; + } + } + void visitAtomicNotify(AtomicNotify* curr) { + // AtomicNotify doesn't strictly write memory, but it does modify the + // waiters list associated with the specified address, which we can think of + // as a write. + readsMemory = true; + writesMemory = true; + isAtomic = true; + if (!ignoreImplicitTraps) { + implicitTrap = true; + } + } + void visitAtomicFence(AtomicFence* curr) { + // AtomicFence should not be reordered with any memory operations, so we set + // these to true. + readsMemory = true; + writesMemory = true; + isAtomic = true; + } + void visitSIMDExtract(SIMDExtract* curr) {} + void visitSIMDReplace(SIMDReplace* curr) {} + void visitSIMDShuffle(SIMDShuffle* curr) {} + void visitSIMDTernary(SIMDTernary* curr) {} + void visitSIMDShift(SIMDShift* curr) {} + void visitSIMDLoad(SIMDLoad* curr) { + readsMemory = true; + if (!ignoreImplicitTraps) { + implicitTrap = true; + } + } + void visitMemoryInit(MemoryInit* curr) { + writesMemory = true; + if (!ignoreImplicitTraps) { + implicitTrap = true; + } + } + void visitDataDrop(DataDrop* curr) { + // data.drop does not actually write memory, but it does alter the size of + // a segment, which can be noticeable later by memory.init, so we need to + // mark it as having a global side effect of some kind. + writesMemory = true; + if (!ignoreImplicitTraps) { + implicitTrap = true; + } + } + void visitMemoryCopy(MemoryCopy* curr) { + readsMemory = true; + writesMemory = true; + if (!ignoreImplicitTraps) { + implicitTrap = true; + } + } + void visitMemoryFill(MemoryFill* curr) { + writesMemory = true; + if (!ignoreImplicitTraps) { + implicitTrap = true; + } + } + void visitConst(Const* curr) {} + void visitUnary(Unary* curr) { + if (!ignoreImplicitTraps) { + switch (curr->op) { + case TruncSFloat32ToInt32: + case TruncSFloat32ToInt64: + case TruncUFloat32ToInt32: + case TruncUFloat32ToInt64: + case TruncSFloat64ToInt32: + case TruncSFloat64ToInt64: + case TruncUFloat64ToInt32: + case TruncUFloat64ToInt64: { + implicitTrap = true; + break; + } + default: { + } + } + } + } + void visitBinary(Binary* curr) { + if (!ignoreImplicitTraps) { + switch (curr->op) { + case DivSInt32: + case DivUInt32: + case RemSInt32: + case RemUInt32: + case DivSInt64: + case DivUInt64: + case RemSInt64: + case RemUInt64: { + implicitTrap = true; + break; + } + default: { + } + } + } + } + void visitSelect(Select* curr) {} + void visitDrop(Drop* curr) {} + void visitReturn(Return* curr) { branchesOut = true; } + void visitMemorySize(MemorySize* curr) { + // memory.size accesses the size of the memory, and thus can be modeled as + // reading memory + readsMemory = true; + // Atomics are sequentially consistent with memory.size. + isAtomic = true; + } + void visitMemoryGrow(MemoryGrow* curr) { + calls = true; + // memory.grow technically does a read-modify-write operation on the memory + // size in the successful case, modifying the set of valid addresses, and + // just a read operation in the failure case + readsMemory = true; + writesMemory = true; + // Atomics are also sequentially consistent with memory.grow. + isAtomic = true; + } + void visitRefNull(RefNull* curr) {} + void visitRefIsNull(RefIsNull* curr) {} + void visitRefFunc(RefFunc* curr) {} + void visitRefEq(RefEq* curr) {} + void visitTry(Try* curr) {} + void visitThrow(Throw* curr) { + if (tryDepth == 0) { + throws = true; + } + } + void visitRethrow(Rethrow* curr) { + if (tryDepth == 0) { + throws = true; + } + if (!ignoreImplicitTraps) { // rethrow traps when the arg is null + implicitTrap = true; + } + } + void visitBrOnExn(BrOnExn* curr) { + breakTargets.insert(curr->name); + if (!ignoreImplicitTraps) { // br_on_exn traps when the arg is null + implicitTrap = true; + } + } + void visitNop(Nop* curr) {} + void visitUnreachable(Unreachable* curr) { branchesOut = true; } + void visitPop(Pop* curr) { + if (catchDepth == 0) { + danglingPop = true; + } + } + void visitTupleMake(TupleMake* curr) {} + void visitTupleExtract(TupleExtract* curr) {} + void visitI31New(I31New* curr) {} + void visitI31Get(I31Get* curr) {} + void visitRefTest(RefTest* curr) { WASM_UNREACHABLE("TODO (gc): ref.test"); } + void visitRefCast(RefCast* curr) { WASM_UNREACHABLE("TODO (gc): ref.cast"); } + void visitBrOnCast(BrOnCast* curr) { + WASM_UNREACHABLE("TODO (gc): br_on_cast"); + } + void visitRttCanon(RttCanon* curr) { + WASM_UNREACHABLE("TODO (gc): rtt.canon"); + } + void visitRttSub(RttSub* curr) { WASM_UNREACHABLE("TODO (gc): rtt.sub"); } + void visitStructNew(StructNew* curr) { + WASM_UNREACHABLE("TODO (gc): struct.new"); + } + void visitStructGet(StructGet* curr) { + WASM_UNREACHABLE("TODO (gc): struct.get"); + } + void visitStructSet(StructSet* curr) { + WASM_UNREACHABLE("TODO (gc): struct.set"); + } + void visitArrayNew(ArrayNew* curr) { + WASM_UNREACHABLE("TODO (gc): array.new"); + } + void visitArrayGet(ArrayGet* curr) { + WASM_UNREACHABLE("TODO (gc): array.get"); + } + void visitArraySet(ArraySet* curr) { + WASM_UNREACHABLE("TODO (gc): array.set"); + } + void visitArrayLen(ArrayLen* curr) { + WASM_UNREACHABLE("TODO (gc): array.len"); + } + + // Helpers + + static bool canReorder(const PassOptions& passOptions, + FeatureSet features, + Expression* a, + Expression* b) { + EffectAnalyzer aEffects(passOptions, features, a); + EffectAnalyzer bEffects(passOptions, features, b); + return !aEffects.invalidates(bEffects); + } + + // C-API + + enum SideEffects : uint32_t { + None = 0, + Branches = 1 << 0, + Calls = 1 << 1, + ReadsLocal = 1 << 2, + WritesLocal = 1 << 3, + ReadsGlobal = 1 << 4, + WritesGlobal = 1 << 5, + ReadsMemory = 1 << 6, + WritesMemory = 1 << 7, + ImplicitTrap = 1 << 8, + IsAtomic = 1 << 9, + Throws = 1 << 10, + DanglingPop = 1 << 11, + Any = (1 << 12) - 1 + }; + uint32_t getSideEffects() const { + uint32_t effects = 0; + if (branchesOut || hasExternalBreakTargets()) { + effects |= SideEffects::Branches; + } + if (calls) { + effects |= SideEffects::Calls; + } + if (localsRead.size() > 0) { + effects |= SideEffects::ReadsLocal; + } + if (localsWritten.size() > 0) { + effects |= SideEffects::WritesLocal; + } + if (globalsRead.size() > 0) { + effects |= SideEffects::ReadsGlobal; + } + if (globalsWritten.size() > 0) { + effects |= SideEffects::WritesGlobal; + } + if (readsMemory) { + effects |= SideEffects::ReadsMemory; + } + if (writesMemory) { + effects |= SideEffects::WritesMemory; + } + if (implicitTrap) { + effects |= SideEffects::ImplicitTrap; + } + if (isAtomic) { + effects |= SideEffects::IsAtomic; + } + if (throws) { + effects |= SideEffects::Throws; + } + if (danglingPop) { + effects |= SideEffects::DanglingPop; + } + return effects; + } + + void ignoreBranches() { + branchesOut = false; + breakTargets.clear(); + } +}; + +} // namespace wasm + +#endif // wasm_ir_effects_h diff --git a/binaryen/src/ir/equivalent_sets.h b/binaryen/src/ir/equivalent_sets.h new file mode 100644 --- /dev/null +++ b/binaryen/src/ir/equivalent_sets.h @@ -0,0 +1,93 @@ +/* + * Copyright 2018 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef wasm_ir_equivalent_sets_h +#define wasm_ir_equivalent_sets_h + +#include + +namespace wasm { + +// +// A map of each index to all those it is equivalent to, and some helpers. +// +struct EquivalentSets { + // A set of indexes. This is ordered for deterministic iteration. + typedef std::set Set; + + std::unordered_map> indexSets; + + // Clears the state completely, removing all equivalences. + void clear() { indexSets.clear(); } + + // Resets an index, removing any equivalences between it and others. + void reset(Index index) { + auto iter = indexSets.find(index); + if (iter != indexSets.end()) { + auto& set = iter->second; + assert(!set->empty()); // can't be empty - we are equal to ourselves! + if (set->size() > 1) { + // We are not the last item, fix things up + set->erase(index); + } + indexSets.erase(iter); + } + } + + // Adds a new equivalence between two indexes. + // `justReset` is an index that was just reset, and has no + // equivalences. `other` may have existing equivalences. + void add(Index justReset, Index other) { + auto iter = indexSets.find(other); + if (iter != indexSets.end()) { + auto& set = iter->second; + set->insert(justReset); + indexSets[justReset] = set; + } else { + auto set = std::make_shared(); + set->insert(justReset); + set->insert(other); + indexSets[justReset] = set; + indexSets[other] = set; + } + } + + // Checks whether two indexes contain the same data. + bool check(Index a, Index b) { + if (a == b) { + return true; + } + if (auto* set = getEquivalents(a)) { + if (set->find(b) != set->end()) { + return true; + } + } + return false; + } + + // Returns the equivalent set, or nullptr + Set* getEquivalents(Index index) { + auto iter = indexSets.find(index); + if (iter != indexSets.end()) { + return iter->second.get(); + } + return nullptr; + } +}; + +} // namespace wasm + +#endif // wasm_ir_equivalent_sets_h diff --git a/binaryen/src/ir/features.h b/binaryen/src/ir/features.h new file mode 100644 --- /dev/null +++ b/binaryen/src/ir/features.h @@ -0,0 +1,183 @@ +/* + * Copyright 2018 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef wasm_ir_features_h +#define wasm_ir_features_h + +#include +#include +#include +#include + +namespace wasm { + +namespace Features { + +inline FeatureSet get(UnaryOp op) { + FeatureSet ret; + switch (op) { + case TruncSatSFloat32ToInt32: + case TruncSatUFloat32ToInt32: + case TruncSatSFloat64ToInt32: + case TruncSatUFloat64ToInt32: + case TruncSatSFloat32ToInt64: + case TruncSatUFloat32ToInt64: + case TruncSatSFloat64ToInt64: + case TruncSatUFloat64ToInt64: { + ret.setTruncSat(); + break; + } + case SplatVecI8x16: + case SplatVecI16x8: + case SplatVecI32x4: + case SplatVecI64x2: + case SplatVecF32x4: + case SplatVecF64x2: + case NotVec128: + case NegVecI8x16: + case AnyTrueVecI8x16: + case AllTrueVecI8x16: + case NegVecI16x8: + case AnyTrueVecI16x8: + case AllTrueVecI16x8: + case NegVecI32x4: + case AnyTrueVecI32x4: + case AllTrueVecI32x4: + case NegVecI64x2: + case AnyTrueVecI64x2: + case AllTrueVecI64x2: + case AbsVecF32x4: + case NegVecF32x4: + case SqrtVecF32x4: + case AbsVecF64x2: + case NegVecF64x2: + case SqrtVecF64x2: + case TruncSatSVecF32x4ToVecI32x4: + case TruncSatUVecF32x4ToVecI32x4: + case TruncSatSVecF64x2ToVecI64x2: + case TruncSatUVecF64x2ToVecI64x2: + case ConvertSVecI32x4ToVecF32x4: + case ConvertUVecI32x4ToVecF32x4: + case ConvertSVecI64x2ToVecF64x2: + case ConvertUVecI64x2ToVecF64x2: { + ret.setSIMD(); + break; + } + case ExtendS8Int32: + case ExtendS16Int32: + case ExtendS8Int64: + case ExtendS16Int64: + case ExtendS32Int64: { + ret.setSignExt(); + break; + } + default: {} + } + return ret; +} + +inline FeatureSet get(BinaryOp op) { + FeatureSet ret; + switch (op) { + case EqVecI8x16: + case NeVecI8x16: + case LtSVecI8x16: + case LtUVecI8x16: + case GtSVecI8x16: + case GtUVecI8x16: + case LeSVecI8x16: + case LeUVecI8x16: + case GeSVecI8x16: + case GeUVecI8x16: + case EqVecI16x8: + case NeVecI16x8: + case LtSVecI16x8: + case LtUVecI16x8: + case GtSVecI16x8: + case GtUVecI16x8: + case LeSVecI16x8: + case LeUVecI16x8: + case GeSVecI16x8: + case GeUVecI16x8: + case EqVecI32x4: + case NeVecI32x4: + case LtSVecI32x4: + case LtUVecI32x4: + case GtSVecI32x4: + case GtUVecI32x4: + case LeSVecI32x4: + case LeUVecI32x4: + case GeSVecI32x4: + case GeUVecI32x4: + case EqVecF32x4: + case NeVecF32x4: + case LtVecF32x4: + case GtVecF32x4: + case LeVecF32x4: + case GeVecF32x4: + case EqVecF64x2: + case NeVecF64x2: + case LtVecF64x2: + case GtVecF64x2: + case LeVecF64x2: + case GeVecF64x2: + case AndVec128: + case OrVec128: + case XorVec128: + case AddVecI8x16: + case AddSatSVecI8x16: + case AddSatUVecI8x16: + case SubVecI8x16: + case SubSatSVecI8x16: + case SubSatUVecI8x16: + case MulVecI8x16: + case AddVecI16x8: + case AddSatSVecI16x8: + case AddSatUVecI16x8: + case SubVecI16x8: + case SubSatSVecI16x8: + case SubSatUVecI16x8: + case MulVecI16x8: + case AddVecI32x4: + case SubVecI32x4: + case MulVecI32x4: + case AddVecI64x2: + case SubVecI64x2: + case AddVecF32x4: + case SubVecF32x4: + case MulVecF32x4: + case DivVecF32x4: + case MinVecF32x4: + case MaxVecF32x4: + case AddVecF64x2: + case SubVecF64x2: + case MulVecF64x2: + case DivVecF64x2: + case MinVecF64x2: + case MaxVecF64x2: { + ret.setSIMD(); + break; + } + default: {} + } + return ret; +} + +} // namespace Features + +} // namespace wasm + +#endif // wasm_ir_features_h diff --git a/binaryen/src/ir/find_all.h b/binaryen/src/ir/find_all.h new file mode 100644 --- /dev/null +++ b/binaryen/src/ir/find_all.h @@ -0,0 +1,73 @@ +/* + * Copyright 2017 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef wasm_ir_find_all_h +#define wasm_ir_find_all_h + +#include + +namespace wasm { + +// Find all instances of a certain node type + +template struct FindAll { + std::vector list; + + FindAll(Expression* ast) { + struct Finder + : public PostWalker> { + std::vector* list; + void visitExpression(Expression* curr) { + if (curr->is()) { + (*list).push_back(curr->cast()); + } + } + }; + Finder finder; + finder.list = &list; + finder.walk(ast); + } +}; + +// Find all pointers to instances of a certain node type + +struct PointerFinder + : public PostWalker> { + Expression::Id id; + std::vector* list; + void visitExpression(Expression* curr) { + if (curr->_id == id) { + (*list).push_back(getCurrentPointer()); + } + } +}; + +template struct FindAllPointers { + std::vector list; + + // Note that a pointer may be to the function->body itself, so we must + // take \ast by reference. + FindAllPointers(Expression*& ast) { + PointerFinder finder; + finder.id = (Expression::Id)T::SpecificId; + finder.list = &list; + finder.walk(ast); + } +}; + +} // namespace wasm + +#endif // wasm_ir_find_all_h diff --git a/binaryen/src/ir/flat.h b/binaryen/src/ir/flat.h new file mode 100644 --- /dev/null +++ b/binaryen/src/ir/flat.h @@ -0,0 +1,127 @@ +/* + * Copyright 2019 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// Flattens code, removing nesting.e.g. an if return value would be +// converted to a local +// +// (i32.add +// (if (..condition..) +// (..if true..) +// (..if false..) +// ) +// (i32.const 1) +// ) +// => +// (if (..condition..) +// (local.set $temp +// (..if true..) +// ) +// (local.set $temp +// (..if false..) +// ) +// ) +// (i32.add +// (local.get $temp) +// (i32.const 1) +// ) +// +// Formally, this pass flattens in the precise sense of +// making the AST have these properties: +// +// 1. Aside from a local.set, the operands of an instruction must be a +// local.get, a const, or an unreachable. Anything else is written +// to a local earlier. +// 2. Disallow control flow (block, loop, if, and try) return values, and do +// not allow the function body to have a concrete type, i.e., do not use +// control flow to pass around values. +// 3. Disallow local.tee, setting a local is always done in a local.set +// on a non-nested-expression location. +// 4. local.set cannot have an operand that is control flow (control flow with +// values is prohibited already, but e.g. a block ending in unreachable, +// which can normally be nested, is also disallowed). +// + +#ifndef wasm_ir_flat_h +#define wasm_ir_flat_h + +#include "ir/iteration.h" +#include "ir/properties.h" +#include "pass.h" +#include "wasm-traversal.h" + +namespace wasm { + +namespace Flat { + +inline void verifyFlatness(Function* func) { + struct VerifyFlatness + : public PostWalker> { + void visitExpression(Expression* curr) { + if (Properties::isControlFlowStructure(curr)) { + verify(!curr->type.isConcrete(), + "control flow structures must not flow values"); + } else if (auto* set = curr->dynCast()) { + verify(!set->isTee() || set->type == Type::unreachable, + "tees are not allowed, only sets"); + verify(!Properties::isControlFlowStructure(set->value), + "set values cannot be control flow"); + } else { + for (auto* child : ChildIterator(curr)) { + verify(Properties::isConstantExpression(child) || + child->is() || child->is(), + "instructions must only have constant expressions, local.get, " + "or unreachable as children"); + } + } + } + + void verify(bool condition, const char* message) { + if (!condition) { + Fatal() << "IR must be flat: run --flatten beforehand (" << message + << ", in " << getFunction()->name << ')'; + } + } + }; + + VerifyFlatness verifier; + verifier.walkFunction(func); + verifier.setFunction(func); + verifier.verify(!func->body->type.isConcrete(), + "function bodies must not flow values"); +} + +inline void verifyFlatness(Module* module) { + struct VerifyFlatness + : public WalkerPass< + PostWalker>> { + bool isFunctionParallel() override { return true; } + + VerifyFlatness* create() override { return new VerifyFlatness(); } + + void doVisitFunction(Function* func) { verifyFlatness(func); } + }; + + PassRunner runner(module); + VerifyFlatness().run(&runner, module); +} + +} // namespace Flat + +} // namespace wasm + +#endif // wasm_ir_flat_h diff --git a/binaryen/src/ir/function-utils.h b/binaryen/src/ir/function-utils.h new file mode 100644 --- /dev/null +++ b/binaryen/src/ir/function-utils.h @@ -0,0 +1,52 @@ +/* + * Copyright 2018 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef wasm_ir_function_h +#define wasm_ir_function_h + +#include "ir/utils.h" +#include "wasm.h" + +namespace wasm { + +namespace FunctionUtils { + +// Checks if two functions are equal in all functional aspects, +// everything but their name (which can't be the same, in the same +// module!) - same params, vars, body, result, etc. +inline bool equal(Function* left, Function* right) { + if (left->sig != right->sig) { + return false; + } + if (left->getNumVars() != right->getNumVars()) { + return false; + } + for (Index i = left->sig.params.size(); i < left->getNumLocals(); i++) { + if (left->getLocalType(i) != right->getLocalType(i)) { + return false; + } + } + if (!left->imported() && !right->imported()) { + return ExpressionAnalyzer::equal(left->body, right->body); + } + return left->imported() && right->imported(); +} + +} // namespace FunctionUtils + +} // namespace wasm + +#endif // wasm_ir_function_h diff --git a/binaryen/src/ir/global-utils.h b/binaryen/src/ir/global-utils.h new file mode 100644 --- /dev/null +++ b/binaryen/src/ir/global-utils.h @@ -0,0 +1,72 @@ +/* + * Copyright 2017 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef wasm_ir_global_h +#define wasm_ir_global_h + +#include +#include + +#include "ir/module-utils.h" +#include "literal.h" +#include "wasm.h" + +namespace wasm { + +namespace GlobalUtils { +// find a global initialized to the value of an import, or null if no such +// global +inline Global* +getGlobalInitializedToImport(Module& wasm, Name module, Name base) { + // find the import + Name imported; + ModuleUtils::iterImportedGlobals(wasm, [&](Global* import) { + if (import->module == module && import->base == base) { + imported = import->name; + } + }); + if (imported.isNull()) { + return nullptr; + } + // find a global inited to it + Global* ret = nullptr; + ModuleUtils::iterDefinedGlobals(wasm, [&](Global* defined) { + if (auto* init = defined->init->dynCast()) { + if (init->name == imported) { + ret = defined; + } + } + }); + return ret; +} + +inline bool canInitializeGlobal(const Expression* curr) { + if (auto* tuple = curr->dynCast()) { + for (auto* op : tuple->operands) { + if (!Properties::isSingleConstantExpression(op) && !op->is()) { + return false; + } + } + return true; + } + return Properties::isSingleConstantExpression(curr) || curr->is(); +} + +} // namespace GlobalUtils + +} // namespace wasm + +#endif // wasm_ir_global_h diff --git a/binaryen/src/ir/hashed.h b/binaryen/src/ir/hashed.h new file mode 100644 --- /dev/null +++ b/binaryen/src/ir/hashed.h @@ -0,0 +1,82 @@ +/* + * Copyright 2017 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef _wasm_ir_hashed_h +#define _wasm_ir_hashed_h + +#include "ir/utils.h" +#include "support/hash.h" +#include "wasm.h" + +namespace wasm { + +// An expression with a cached hash value +struct HashedExpression { + Expression* expr; + size_t digest; + + HashedExpression(Expression* expr) : expr(expr) { + if (expr) { + digest = ExpressionAnalyzer::hash(expr); + } else { + digest = hash(0); + } + } + + HashedExpression(const HashedExpression& other) + : expr(other.expr), digest(other.digest) {} +}; + +// A pass that hashes all functions + +struct FunctionHasher : public WalkerPass> { + bool isFunctionParallel() override { return true; } + + struct Map : public std::map {}; + + FunctionHasher(Map* output) : output(output) {} + + FunctionHasher* create() override { return new FunctionHasher(output); } + + static Map createMap(Module* module) { + Map hashes; + for (auto& func : module->functions) { + // ensure an entry for each function - we must not modify the map shape in + // parallel, just the values + hashes[func.get()] = hash(0); + } + return hashes; + } + + void doWalkFunction(Function* func) { output->at(func) = hashFunction(func); } + + static size_t hashFunction(Function* func) { + auto digest = hash(func->sig.params.getID()); + rehash(digest, func->sig.results.getID()); + for (auto type : func->vars) { + rehash(digest, type.getID()); + } + hash_combine(digest, ExpressionAnalyzer::hash(func->body)); + return digest; + } + +private: + Map* output; +}; + +} // namespace wasm + +#endif // _wasm_ir_hashed_h diff --git a/binaryen/src/ir/import-utils.h b/binaryen/src/ir/import-utils.h new file mode 100644 --- /dev/null +++ b/binaryen/src/ir/import-utils.h @@ -0,0 +1,106 @@ +/* + * Copyright 2017 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef wasm_ir_import_h +#define wasm_ir_import_h + +#include "literal.h" +#include "wasm.h" + +namespace wasm { + +// Collects info on imports, into a form convenient for summarizing +// and searching. +struct ImportInfo { + Module& wasm; + + std::vector importedGlobals; + std::vector importedFunctions; + std::vector importedEvents; + + ImportInfo(Module& wasm) : wasm(wasm) { + for (auto& import : wasm.globals) { + if (import->imported()) { + importedGlobals.push_back(import.get()); + } + } + for (auto& import : wasm.functions) { + if (import->imported()) { + importedFunctions.push_back(import.get()); + } + } + for (auto& import : wasm.events) { + if (import->imported()) { + importedEvents.push_back(import.get()); + } + } + } + + Global* getImportedGlobal(Name module, Name base) { + for (auto* import : importedGlobals) { + if (import->module == module && import->base == base) { + return import; + } + } + return nullptr; + } + + Function* getImportedFunction(Name module, Name base) { + for (auto* import : importedFunctions) { + if (import->module == module && import->base == base) { + return import; + } + } + return nullptr; + } + + Event* getImportedEvent(Name module, Name base) { + for (auto* import : importedEvents) { + if (import->module == module && import->base == base) { + return import; + } + } + return nullptr; + } + + Index getNumImportedGlobals() { return importedGlobals.size(); } + + Index getNumImportedFunctions() { return importedFunctions.size(); } + + Index getNumImportedEvents() { return importedEvents.size(); } + + Index getNumImports() { + return getNumImportedGlobals() + getNumImportedFunctions() + + getNumImportedEvents() + (wasm.memory.imported() ? 1 : 0) + + (wasm.table.imported() ? 1 : 0); + } + + Index getNumDefinedGlobals() { + return wasm.globals.size() - getNumImportedGlobals(); + } + + Index getNumDefinedFunctions() { + return wasm.functions.size() - getNumImportedFunctions(); + } + + Index getNumDefinedEvents() { + return wasm.events.size() - getNumImportedEvents(); + } +}; + +} // namespace wasm + +#endif // wasm_ir_import_h diff --git a/binaryen/src/ir/iteration.h b/binaryen/src/ir/iteration.h new file mode 100644 --- /dev/null +++ b/binaryen/src/ir/iteration.h @@ -0,0 +1,137 @@ +/* + * Copyright 2018 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef wasm_ir_iteration_h +#define wasm_ir_iteration_h + +#include "ir/properties.h" +#include "wasm-traversal.h" +#include "wasm.h" + +namespace wasm { + +// +// Allows iteration over the children of the expression, in order of execution +// where relevant. +// +// * This skips missing children, e.g. if an if has no else, it is represented +// as having 2 children (and not 3 with the last a nullptr). +// +// In general, it is preferable not to use this class and to directly access the +// children (using e.g. iff->ifTrue etc.), as that is faster. However, in cases +// where speed does not matter, this can be convenient. TODO: reimplement these +// to avoid materializing all the chilren at once. +// +// ChildIterator - Iterates over all children +// +// ValueChildIterator - Iterates over all children that produce values used by +// this instruction. For example, includes If::condition +// but not If::ifTrue. +// +template class Scanner> class AbstractChildIterator { + using Self = AbstractChildIterator; + struct Iterator { + const Self& parent; + Index index; + + Iterator(const Self& parent, Index index) : parent(parent), index(index) {} + + bool operator!=(const Iterator& other) const { + return index != other.index || &parent != &(other.parent); + } + + void operator++() { index++; } + + Expression* operator*() { return parent.children[index]; } + }; + +public: + SmallVector children; + + AbstractChildIterator(Expression* parent) { + struct Traverser : public PostWalker { + Expression* parent; + SmallVector* children; + + // We need to scan subchildren exactly once - just the parent. + bool scanned = false; + + static void scan(Traverser* self, Expression** currp) { + if (!self->scanned) { + self->scanned = true; + Scanner>::scan(self, + currp); + } else { + // This is one of the children. Do not scan further, just note it. + self->children->push_back(*currp); + } + } + } traverser; + traverser.parent = parent; + traverser.children = &children; + traverser.walk(parent); + } + + Iterator begin() const { return Iterator(*this, 0); } + Iterator end() const { return Iterator(*this, children.size()); } +}; + +template +struct ValueChildScanner : PostWalker { + static void scan(SubType* self, Expression** currp) { + auto* curr = *currp; + if (Properties::isControlFlowStructure(curr)) { + // If conditions are the only value children of control flow structures + if (auto* iff = curr->dynCast()) { + self->pushTask(SubType::scan, &iff->condition); + } + } else { + // All children on non-control flow expressions are value children + PostWalker::scan(self, currp); + } + } +}; + +using ChildIterator = AbstractChildIterator; +using ValueChildIterator = AbstractChildIterator; + +// Returns true if the current expression contains a certain kind of expression, +// within the given depth of BFS. If depth is -1, this searches all children. +template bool containsChild(Expression* parent, int depth = -1) { + std::vector exprs; + std::vector nextExprs; + exprs.push_back(parent); + while (!exprs.empty() && depth > 0) { + for (auto* expr : exprs) { + for (auto* child : ChildIterator(expr)) { + if (child->is()) { + return true; + } + nextExprs.push_back(child); + } + } + exprs.swap(nextExprs); + nextExprs.clear(); + if (depth > 0) { + depth--; + } + } + return false; +} + +} // namespace wasm + +#endif // wasm_ir_iteration_h diff --git a/binaryen/src/ir/label-utils.h b/binaryen/src/ir/label-utils.h new file mode 100644 --- /dev/null +++ b/binaryen/src/ir/label-utils.h @@ -0,0 +1,55 @@ +/* + * Copyright 2017 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef wasm_ir_label_h +#define wasm_ir_label_h + +#include "wasm-traversal.h" +#include "wasm.h" + +namespace wasm { + +namespace LabelUtils { + +// Handles branch/loop labels in a function; makes it easy to add new +// ones without duplicates +class LabelManager : public PostWalker { +public: + LabelManager(Function* func) { walkFunction(func); } + + Name getUnique(std::string prefix) { + while (1) { + auto curr = Name(prefix + std::to_string(counter++)); + if (labels.find(curr) == labels.end()) { + labels.insert(curr); + return curr; + } + } + } + + void visitBlock(Block* curr) { labels.insert(curr->name); } + void visitLoop(Loop* curr) { labels.insert(curr->name); } + +private: + std::set labels; + size_t counter = 0; +}; + +} // namespace LabelUtils + +} // namespace wasm + +#endif // wasm_ir_label_h diff --git a/binaryen/src/ir/literal-utils.h b/binaryen/src/ir/literal-utils.h new file mode 100644 --- /dev/null +++ b/binaryen/src/ir/literal-utils.h @@ -0,0 +1,48 @@ +/* + * Copyright 2017 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef wasm_ir_literal_utils_h +#define wasm_ir_literal_utils_h + +#include "wasm-builder.h" +#include "wasm.h" + +namespace wasm { + +namespace LiteralUtils { + +inline Expression* makeFromInt32(int32_t x, Type type, Module& wasm) { + auto* ret = wasm.allocator.alloc(); + ret->value = Literal::makeFromInt32(x, type); + ret->type = type; + return ret; +} + +inline Expression* makeZero(Type type, Module& wasm) { + // TODO: Remove this function once V8 supports v128.const + // (https://bugs.chromium.org/p/v8/issues/detail?id=8460) + Builder builder(wasm); + if (type == Type::v128) { + return builder.makeUnary(SplatVecI32x4, builder.makeConst(int32_t(0))); + } + return builder.makeConstantExpression(Literal::makeZeros(type)); +} + +} // namespace LiteralUtils + +} // namespace wasm + +#endif // wasm_ir_literal_utils_h diff --git a/binaryen/src/ir/load-utils.h b/binaryen/src/ir/load-utils.h new file mode 100644 --- /dev/null +++ b/binaryen/src/ir/load-utils.h @@ -0,0 +1,44 @@ +/* + * Copyright 2017 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef wasm_ir_load_h +#define wasm_ir_load_h + +#include "wasm.h" + +namespace wasm { + +namespace LoadUtils { + +// checks if the sign of a load matters, which is when an integer +// load is of fewer bytes than the size of the type (so we must +// fill in bits either signed or unsigned wise) +inline bool isSignRelevant(Load* load) { + auto type = load->type; + if (load->type == Type::unreachable) { + return false; + } + return !type.isFloat() && load->bytes < type.getByteSize(); +} + +// check if a load can be signed (which some opts want to do) +inline bool canBeSigned(Load* load) { return !load->isAtomic; } + +} // namespace LoadUtils + +} // namespace wasm + +#endif // wasm_ir_load_h diff --git a/binaryen/src/ir/local-graph.h b/binaryen/src/ir/local-graph.h new file mode 100644 --- /dev/null +++ b/binaryen/src/ir/local-graph.h @@ -0,0 +1,92 @@ +/* + * Copyright 2017 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef wasm_ir_local_graph_h +#define wasm_ir_local_graph_h + +#include "wasm.h" + +namespace wasm { + +// +// Finds the connections between local.gets and local.sets, creating +// a graph of those ties. This is useful for "ssa-style" optimization, +// in which you want to know exactly which sets are relevant for a +// a get, so it is as if each get has just one set, logically speaking +// (see the SSA pass for actually creating new local indexes based +// on this). +// +struct LocalGraph { + // main API + + // the constructor computes getSetses, the sets affecting each get + LocalGraph(Function* func); + + // the local.sets relevant for an index or a get. + typedef std::set Sets; + + typedef std::map GetSetses; + + typedef std::map Locations; + + // externally useful information + GetSetses getSetses; // the sets affecting each get. a nullptr set means the + // initial value (0 for a var, the received value for a + // param) + Locations locations; // where each get and set is (for easy replacing) + + // Optional: compute the influence graphs between sets and gets + // (useful for algorithms that propagate changes). + + void computeInfluences(); + + // for each get, the sets whose values are influenced by that get + std::unordered_map> getInfluences; + // for each set, the gets whose values are influenced by that set + std::unordered_map> setInfluences; + + // Optional: Compute the local indexes that are SSA, in the sense of + // * a single set for all the gets for that local index + // * the set dominates all the gets (logically implied by the former + // property) + // * no other set (aside from the zero-init) + // The third property is not exactly standard SSA, but is useful since we are + // not in SSA form in our IR. To see why it matters, consider these: + // + // x = 0 // zero init + // [..] + // x = 10 + // y = x + 20 + // x = 30 // !!! + // f(y) + // + // The !!! line violates that property - it is another set for x, and it may + // interfere say with replacing f(y) with f(x + 20). Instead, if we know the + // only other possible set for x is the zero init, then things like the !!! + // line cannot exist, and it is valid to replace f(y) with f(x + 20). (This + // could be simpler, but in wasm the zero init always exists.) + + void computeSSAIndexes(); + + bool isSSA(Index x); + +private: + std::set SSAIndexes; +}; + +} // namespace wasm + +#endif // wasm_ir_local_graph_h diff --git a/binaryen/src/ir/local-utils.h b/binaryen/src/ir/local-utils.h new file mode 100644 --- /dev/null +++ b/binaryen/src/ir/local-utils.h @@ -0,0 +1,113 @@ +/* + * Copyright 2019 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef wasm_ir_local_utils_h +#define wasm_ir_local_utils_h + +#include +#include + +namespace wasm { + +struct LocalGetCounter : public PostWalker { + std::vector num; + + LocalGetCounter() = default; + LocalGetCounter(Function* func) { analyze(func, func->body); } + LocalGetCounter(Function* func, Expression* ast) { analyze(func, ast); } + + void analyze(Function* func) { analyze(func, func->body); } + void analyze(Function* func, Expression* ast) { + num.resize(func->getNumLocals()); + std::fill(num.begin(), num.end(), 0); + walk(ast); + } + + void visitLocalGet(LocalGet* curr) { num[curr->index]++; } +}; + +// Removes trivially unneeded sets: sets for whom there is no possible get, and +// sets of the same value immediately. +struct UnneededSetRemover : public PostWalker { + PassOptions& passOptions; + + LocalGetCounter* localGetCounter = nullptr; + FeatureSet features; + + UnneededSetRemover(Function* func, + PassOptions& passOptions, + FeatureSet features) + : passOptions(passOptions), features(features) { + LocalGetCounter counter(func); + UnneededSetRemover inner(counter, func, passOptions, features); + removed = inner.removed; + } + + UnneededSetRemover(LocalGetCounter& localGetCounter, + Function* func, + PassOptions& passOptions, + FeatureSet features) + : passOptions(passOptions), localGetCounter(&localGetCounter), + features(features) { + walk(func->body); + } + + bool removed = false; + + void visitLocalSet(LocalSet* curr) { + // If no possible uses, remove. + if (localGetCounter->num[curr->index] == 0) { + remove(curr); + } + // If setting the same value as we already have, remove. + auto* value = curr->value; + while (true) { + if (auto* set = value->dynCast()) { + if (set->index == curr->index) { + remove(curr); + } else { + // Handle tee chains. + value = set->value; + continue; + } + } else if (auto* get = value->dynCast()) { + if (get->index == curr->index) { + remove(curr); + } + } + break; + } + } + + void remove(LocalSet* set) { + auto* value = set->value; + if (set->isTee()) { + replaceCurrent(value); + } else if (EffectAnalyzer(passOptions, features, set->value) + .hasSideEffects()) { + Drop* drop = ExpressionManipulator::convert(set); + drop->value = value; + drop->finalize(); + } else { + ExpressionManipulator::nop(set); + } + removed = true; + } +}; + +} // namespace wasm + +#endif // wasm_ir_local_utils_h diff --git a/binaryen/src/ir/localize.h b/binaryen/src/ir/localize.h new file mode 100644 --- /dev/null +++ b/binaryen/src/ir/localize.h @@ -0,0 +1,46 @@ +/* + * Copyright 2016 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef wasm_ir_localizer_h +#define wasm_ir_localizer_h + +#include + +namespace wasm { + +// Make an expression available in a local. If already in one, just +// use that local, otherwise use a new local + +struct Localizer { + Index index; + Expression* expr; + + Localizer(Expression* input, Function* func, Module* wasm) { + expr = input; + if (auto* get = expr->dynCast()) { + index = get->index; + } else if (auto* set = expr->dynCast()) { + index = set->index; + } else { + index = Builder::addVar(func, expr->type); + expr = Builder(*wasm).makeLocalTee(index, expr, expr->type); + } + } +}; + +} // namespace wasm + +#endif // wasm_ir_localizer_h diff --git a/binaryen/src/ir/manipulation.h b/binaryen/src/ir/manipulation.h new file mode 100644 --- /dev/null +++ b/binaryen/src/ir/manipulation.h @@ -0,0 +1,82 @@ +/* + * Copyright 2017 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef wasm_ir_manipulation_h +#define wasm_ir_manipulation_h + +#include "wasm.h" + +namespace wasm { + +namespace ExpressionManipulator { +// Re-use a node's memory. This helps avoid allocation when optimizing. +template +inline OutputType* convert(InputType* input) { + static_assert(sizeof(OutputType) <= sizeof(InputType), + "Can only convert to a smaller size Expression node"); + input->~InputType(); // arena-allocaed, so no destructor, but avoid UB. + OutputType* output = (OutputType*)(input); + new (output) OutputType; + return output; +} + +// Convenience methods for certain instructions, which are common conversions +template inline Nop* nop(InputType* target) { + auto* ret = convert(target); + ret->finalize(); + return ret; +} + +template +inline RefNull* refNull(InputType* target, Type type) { + auto* ret = convert(target); + ret->finalize(type); + return ret; +} + +template +inline Unreachable* unreachable(InputType* target) { + auto* ret = convert(target); + ret->finalize(); + return ret; +} + +// Convert a node that allocates +template +inline OutputType* convert(InputType* input, MixedArena& allocator) { + assert(sizeof(OutputType) <= sizeof(InputType)); + input->~InputType(); // arena-allocaed, so no destructor, but avoid UB. + OutputType* output = (OutputType*)(input); + new (output) OutputType(allocator); + return output; +} + +using CustomCopier = std::function; +Expression* +flexibleCopy(Expression* original, Module& wasm, CustomCopier custom); + +inline Expression* copy(Expression* original, Module& wasm) { + auto copy = [](Expression* curr) { return nullptr; }; + return flexibleCopy(original, wasm, copy); +} + +// Splice an item into the middle of a block's list +void spliceIntoBlock(Block* block, Index index, Expression* add); +} // namespace ExpressionManipulator + +} // namespace wasm + +#endif // wams_ir_manipulation_h diff --git a/binaryen/src/ir/match.h b/binaryen/src/ir/match.h new file mode 100644 --- /dev/null +++ b/binaryen/src/ir/match.h @@ -0,0 +1,848 @@ +/* + * Copyright 2020 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// match.h - Provides an easily extensible layered API for matching expression +// patterns and extracting their components. The low-level API provides modular +// building blocks for creating matchers for any data type and the high-level +// API provides a succinct and flexible interface for matching expressions and +// extracting useful information from them. + +#ifndef wasm_ir_match_h +#define wasm_ir_match_h + +#include "ir/abstract.h" +#include "wasm.h" + +namespace wasm { + +namespace Match { + +// The available matchers are: +// +// i32, i64, f32, f64 +// +// Match constants of the corresponding type. Takes zero or one argument. The +// argument can be a specific value to match or it can be a pointer to a +// value, Literal, or Const* at which to store the matched entity. +// +// ival, fval +// +// Match any integer constant or any floating point constant. Takes neither, +// either, or both of two possible arguments: first, a pointer to a value, +// Literal, or Const* at which to store the matched entity and second, a +// specific value to match. +// +// constant +// +// Matches any numeric Const expression. Takes neither, either, or both of +// two possible arguments: first, a pointer to either Literal or Const* at +// which to store the matched entity and second, a specific value (given as +// an int32_t) to match.. +// +// any +// +// Matches any Expression. Optionally takes as an argument a pointer to +// Expression* at which to store the matched Expression*. +// +// unary +// +// Matches Unary expressions. Takes an optional pointer to Unary* at which to +// store the matched Unary*, followed by either a UnaryOp or an Abstract::Op +// describing which unary expressions to match, followed by a matcher to +// apply to the unary expression's operand. +// +// binary +// +// Matches Binary expressions. Takes an optional pointer to Binary* at which +// to store the matched Binary*, followed by either a BinaryOp or an +// Abstract::Op describing which binary expresions to match, followed by +// matchers to apply to the binary expression's left and right operands. +// +// select +// +// Matches Select expressions. Takes an optional pointer to Select* at which +// to store the matched Select*, followed by matchers to apply to the ifTrue, +// ifFalse, and condition operands. +// +// +// How to create new matchers: +// +// Lets add a matcher for an expression type that is declared in wasm.h: +// +// class Frozzle : public SpecificExpression { +// public: +// Expression* foo; +// Expression* bar; +// Expression* baz; +// }; +// +// This expression is very simple; in order to match it, all we need to do is +// apply other matchers to its subexpressions. The matcher infrastructure will +// handle this automatically once we tell it how to access the subexpressions. +// To tell the matcher infrastructure how many subexpressions there are we need +// to specialize `NumComponents`. +// +// template<> struct NumComponents { +// static constexpr size_t value = 3; +// }; +// +// And to tell the matcher infrastructure how to access those three +// subexpressions, we need to specialize `GetComponent` three times. +// +// template<> struct GetComponent { +// Expression* operator()(Frozzle* curr) { return curr->foo; } +// }; +// template<> struct GetComponent { +// Expression* operator()(Frozzle* curr) { return curr->bar; } +// }; +// template<> struct GetComponent { +// Expression* operator()(Frozzle* curr) { return curr->baz; } +// }; +// +// For simple expressions, that's all we need to do to get a fully functional +// matcher that we can construct and use like this, where S1, S2, and S3 are +// the types of the submatchers to use and s1, s2, and s3 are instances of +// those types: +// +// Frozzle* extracted; +// auto matcher = Matcher(&extracted, {}, s1, s2, s3); +// if (matches(expr, matcher)) { +// // `extracted` set to `expr` here +// } +// +// It's annoying to have to write out the types S1, S2, and S3 and we don't get +// class template argument deduction (CTAD) until C++17, so it's useful to +// create a wrapper function so can take advantage of function template +// argument deduction. We can also take this opportunity to make the interface +// more compact. +// +// template +// inline decltype(auto) frozzle(Frozzle** binder, +// S1&& s1, S2&& s2, S3&& s3) { +// return Matcher(binder, {}, s1, s2, s3); +// } +// template +// inline decltype(auto) frozzle(S1&& s1, S2&& s2, S3&& s3) { +// return Matcher(nullptr, {}, s1, s2, s3); +// } +// +// Notice that we make the interface more compact by providing overloads with +// and without the binder. Here is the final matcher usage: +// +// Frozzle* extracted; +// if (matches(expr, frozzle(&extracted, s1, s2, s3))) { +// // `extracted` set to `expr` here +// } +// +// Some matchers are more complicated, though, because they need to do +// something besides just applying submatchers to the components of an +// expression. These matchers require slightly more work. +// +// +// Complex matchers: +// +// Lets add a matcher that will match calls to functions whose names start with +// certain prefixes. Since this is not a normal matcher for Call expressions, +// we can't identify it by the Call* type. Instead, we have to create a new +// identifier type, called a "Kind" for it. +// +// struct PrefixCallKind {}; +// +// Next, since we're not in the common case of using a specific expression +// pointer as our kind, we have to tell the matcher infrastructure what type of +// thing this matcher matches. Since we want this matcher to be able to match +// any given prefix, we also need the matcher to contain the given prefix as +// state, and we need to tell the matcher infrastructure what type that state +// is as well. To specify these types, we need to specialize +// `KindTypeRegistry` for `PrefixCallKind`. +// +// template<> struct KindTypeRegistry { +// using matched_t = Call*; +// using data_t = Name; +// }; +// +// Note that because `matched_t` is set to a specific expression pointer, this +// matcher will automatically be able to be applied to any `Expression*`, not +// just `Call*`. If `matched_t` were not a specific expression pointer, this +// matcher would only be able to be applied to types compatible with +// `matched_t`. Also note that if a matcher does not need to store any state, +// its `data_t` should be set to `unused_t`. +// +// Now we need to tell the matcher infrastructure what custom logic to apply +// for this matcher. We do this by specializing `MatchSelf`. +// +// template<> struct MatchSelf { +// bool operator()(Call* curr, Name prefix) { +// return curr->name.startsWith(prefix); +// } +// }; +// +// Note that the first parameter to `MatchSelf::operator()` will be that +// kind's `matched_t` and the second parameter will be that kind's `data_t`, +// which may be `unused_t`. (TODO: detect if `data_t` is `unused_t` and don't +// expose it in the Matcher interface if so.) +// +// After this, everything is the same as in the simple matcher case. This +// particular matcher doesn't need to recurse into any subcomponents, so we can +// skip straight to creating the wrapper function. +// +// decltype(auto) prefixCall(Call** binder, Name prefix) { +// return Matcher(binder, prefix); +// } +// +// Now we can use the new matcher: +// +// Call* call; +// if (matches(expr, prefixCall(&call, "__foo"))) { +// // `call` set to `expr` here +// } +// + +// The main entrypoint for matching. If the match succeeds, all variables bound +// in the matcher will be set to their corresponding matched values. Otherwise, +// the value of the bound variables is unspecified and may have changed. +template inline bool matches(Expression* expr, Matcher matcher) { + return matcher.matches(expr); +} + +namespace Internal { + +struct unused_t {}; + +// Each matcher has a `Kind`, which controls how candidate values are +// destructured and inspected. For most matchers, `Kind` is a pointer to the +// matched subtype of Expression, but when there are multiple matchers for the +// same kind of expression, they are disambiguated by having different `Kind`s. +// In this case, or if the matcher matches something besides a pointer to a +// subtype of Expression, or if the matcher requires additional state, the +// matched type and the type of additional state must be associated with the +// `Kind` via a specialization of `KindTypeRegistry`. +template struct KindTypeRegistry { + // The matched type + using matched_t = void; + // The type of additional state needed to perform a match. Can be set to + // `unused_t` if it's not needed. + using data_t = unused_t; +}; + +// Given a `Kind`, produce the type `matched_t` that is matched by that Kind and +// the type `candidate_t` that is the type of the parameter of the `matches` +// method. These types are only different if `matched_t` is a pointer to a +// subtype of Expression, in which case `candidate_t` is Expression*. +template struct MatchTypes { + using matched_t = typename std::conditional_t< + std::is_base_of>::value, + Kind, + typename KindTypeRegistry::matched_t>; + + static constexpr bool isExpr = + std::is_base_of>::value; + + using candidate_t = + typename std::conditional_t; +}; + +template using matched_t = typename MatchTypes::matched_t; +template using candidate_t = typename MatchTypes::candidate_t; +template using data_t = typename KindTypeRegistry::data_t; + +// Defined if the matched type is a specific expression pointer, so can be +// `dynCast`ed to from Expression*. +template +using enable_if_castable_t = typename std::enable_if< + std::is_base_of>>::value && + !std::is_same>::value, + int>::type; + +// Opposite of above +template +using enable_if_not_castable_t = typename std::enable_if< + !std::is_base_of>>::value || + std::is_same>::value, + int>::type; + +// Do a normal dynCast from Expression* to the subtype, storing the result in +// `out` and returning `true` iff the cast succeeded. +template = 0> +inline bool dynCastCandidate(candidate_t candidate, + matched_t& out) { + out = candidate->template dynCast>>(); + return out != nullptr; +} + +// Otherwise we are not matching an Expression, so this is infallible. +template = 0> +inline bool dynCastCandidate(candidate_t candidate, + matched_t& out) { + out = candidate; + return true; +} + +// Matchers can optionally specialize this to perform custom matching logic +// before recursing into submatchers, potentially short-circuiting the match. +// Uses a struct because partial specialization of functions is not allowed. +template struct MatchSelf { + bool operator()(matched_t, data_t) { return true; } +}; + +// Used to statically ensure that each matcher has the correct number of +// submatchers. This needs to be specialized for each kind of matcher that has +// submatchers. +template struct NumComponents { + static constexpr size_t value = 0; +}; + +// Every kind of matcher needs to partially specialize this for each of its +// components. Each specialization should define +// +// T operator()(matched_t) +// +// where T is the component's type. Components will be matched from first to +// last. Uses a struct instead of a function because partial specialization of +// functions is not allowed. +template struct GetComponent; + +// A type-level linked list to hold an arbitrary number of matchers. +template struct SubMatchers {}; +template +struct SubMatchers { + CurrMatcher curr; + SubMatchers next; + SubMatchers(CurrMatcher curr, NextMatchers... next) + : curr(curr), next(next...){}; +}; + +// Iterates through the components of the candidate, applying a submatcher to +// each component. Uses a struct instead of a function because partial +// specialization of functions is not allowed. +template +struct Components { + static inline bool + match(matched_t candidate, + SubMatchers& matchers) { + return matchers.curr.matches(GetComponent{}(candidate)) && + Components::match(candidate, + matchers.next); + } +}; +template struct Components { + static_assert(pos == NumComponents::value, + "Unexpected number of submatchers"); + static inline bool match(matched_t, SubMatchers<>) { + // Base case when there are no components left; trivially true. + return true; + } +}; + +template struct Matcher { + matched_t* binder; + data_t data; + SubMatchers submatchers; + + Matcher(matched_t* binder, data_t data, Matchers... submatchers) + : binder(binder), data(data), submatchers(submatchers...) {} + + inline bool matches(candidate_t candidate) { + matched_t casted; + if (dynCastCandidate(candidate, casted)) { + if (binder != nullptr) { + *binder = casted; + } + return MatchSelf{}(casted, data) && + Components::match(casted, submatchers); + } + return false; + } +}; + +// Concrete low-level matcher implementations. Not intended for direct external +// use. + +// Any: matches any value of the expected type +template struct AnyKind {}; +template struct KindTypeRegistry> { + using matched_t = T; + using data_t = unused_t; +}; +template inline decltype(auto) Any(T* binder) { + return Matcher>(binder, {}); +} + +// Exact: matches exact values of the expected type +template struct ExactKind {}; +template struct KindTypeRegistry> { + using matched_t = T; + using data_t = T; +}; +template struct MatchSelf> { + bool operator()(T self, T expected) { return self == expected; } +}; +template inline decltype(auto) Exact(T* binder, T data) { + return Matcher>(binder, data); +} + +// {I32,I64,Int,F32,F64,Float,Number}Lit: match `Literal` of the expected `Type` +struct I32LK { + static bool matchType(Literal lit) { return lit.type == Type::i32; } + static int32_t getVal(Literal lit) { return lit.geti32(); } +}; +struct I64LK { + static bool matchType(Literal lit) { return lit.type == Type::i64; } + static int64_t getVal(Literal lit) { return lit.geti64(); } +}; +struct IntLK { + static bool matchType(Literal lit) { return lit.type.isInteger(); } + static int64_t getVal(Literal lit) { return lit.getInteger(); } +}; +struct F32LK { + static bool matchType(Literal lit) { return lit.type == Type::f32; } + static float getVal(Literal lit) { return lit.getf32(); } +}; +struct F64LK { + static bool matchType(Literal lit) { return lit.type == Type::f64; } + static double getVal(Literal lit) { return lit.getf64(); } +}; +struct FloatLK { + static bool matchType(Literal lit) { return lit.type.isFloat(); } + static double getVal(Literal lit) { return lit.getFloat(); } +}; +template struct LitKind {}; +template struct KindTypeRegistry> { + using matched_t = Literal; + using data_t = unused_t; +}; +template struct MatchSelf> { + bool operator()(Literal lit, unused_t) { return T::matchType(lit); } +}; +template struct NumComponents> { + static constexpr size_t value = 1; +}; +template struct GetComponent, 0> { + decltype(auto) operator()(Literal lit) { return T::getVal(lit); } +}; +template inline decltype(auto) I32Lit(Literal* binder, S&& s) { + return Matcher, S>(binder, {}, s); +} +template inline decltype(auto) I64Lit(Literal* binder, S&& s) { + return Matcher, S>(binder, {}, s); +} +template inline decltype(auto) IntLit(Literal* binder, S&& s) { + return Matcher, S>(binder, {}, s); +} +template inline decltype(auto) F32Lit(Literal* binder, S&& s) { + return Matcher, S>(binder, {}, s); +} +template inline decltype(auto) F64Lit(Literal* binder, S&& s) { + return Matcher, S>(binder, {}, s); +} +template inline decltype(auto) FloatLit(Literal* binder, S&& s) { + return Matcher, S>(binder, {}, s); +} +struct NumberLitKind {}; +template<> struct KindTypeRegistry { + using matched_t = Literal; + using data_t = int32_t; +}; +template<> struct MatchSelf { + bool operator()(Literal lit, int32_t expected) { + return lit.type.isNumber() && + Literal::makeFromInt32(expected, lit.type) == lit; + } +}; +inline decltype(auto) NumberLit(Literal* binder, int32_t expected) { + return Matcher(binder, expected); +} + +// Const +template<> struct NumComponents { static constexpr size_t value = 1; }; +template<> struct GetComponent { + Literal operator()(Const* c) { return c->value; } +}; +template inline decltype(auto) ConstMatcher(Const** binder, S&& s) { + return Matcher(binder, {}, s); +} + +// Unary, UnaryOp and AbstractUnaryOp +template<> struct NumComponents { static constexpr size_t value = 2; }; +template<> struct GetComponent { + UnaryOp operator()(Unary* curr) { return curr->op; } +}; +template<> struct GetComponent { + Expression* operator()(Unary* curr) { return curr->value; } +}; +struct UnaryOpK { + using Op = UnaryOp; + static UnaryOp getOp(Type, Op op) { return op; } +}; +struct AbstractUnaryOpK { + using Op = Abstract::Op; + static UnaryOp getOp(Type type, Abstract::Op op) { + return Abstract::getUnary(type, op); + } +}; +template struct UnaryOpKind {}; +template struct KindTypeRegistry> { + using matched_t = Unary*; + using data_t = typename T::Op; +}; +template struct MatchSelf> { + bool operator()(Unary* curr, typename T::Op op) { + return curr->op == T::getOp(curr->value->type, op); + } +}; +template struct NumComponents> { + static constexpr size_t value = 1; +}; +template struct GetComponent, 0> { + Expression* operator()(Unary* curr) { return curr->value; } +}; +template +inline decltype(auto) UnaryMatcher(Unary** binder, S1&& s1, S2&& s2) { + return Matcher(binder, {}, s1, s2); +} +template +inline decltype(auto) UnaryOpMatcher(Unary** binder, UnaryOp op, S&& s) { + return Matcher, S>(binder, op, s); +} +template +inline decltype(auto) +AbstractUnaryOpMatcher(Unary** binder, Abstract::Op op, S&& s) { + return Matcher, S>(binder, op, s); +} + +// Binary, BinaryOp and AbstractBinaryOp +template<> struct NumComponents { static constexpr size_t value = 3; }; +template<> struct GetComponent { + BinaryOp operator()(Binary* curr) { return curr->op; } +}; +template<> struct GetComponent { + Expression* operator()(Binary* curr) { return curr->left; } +}; +template<> struct GetComponent { + Expression* operator()(Binary* curr) { return curr->right; } +}; +struct BinaryOpK { + using Op = BinaryOp; + static BinaryOp getOp(Type, Op op) { return op; } +}; +struct AbstractBinaryOpK { + using Op = Abstract::Op; + static BinaryOp getOp(Type type, Abstract::Op op) { + return Abstract::getBinary(type, op); + } +}; +template struct BinaryOpKind {}; +template struct KindTypeRegistry> { + using matched_t = Binary*; + using data_t = typename T::Op; +}; +template struct MatchSelf> { + bool operator()(Binary* curr, typename T::Op op) { + return curr->op == T::getOp(curr->left->type, op); + } +}; +template struct NumComponents> { + static constexpr size_t value = 2; +}; +template struct GetComponent, 0> { + Expression* operator()(Binary* curr) { return curr->left; } +}; +template struct GetComponent, 1> { + Expression* operator()(Binary* curr) { return curr->right; } +}; +template +inline decltype(auto) +BinaryMatcher(Binary** binder, S1&& s1, S2&& s2, S3&& s3) { + return Matcher(binder, {}, s1, s2, s3); +} +template +inline decltype(auto) +BinaryOpMatcher(Binary** binder, BinaryOp op, S1&& s1, S2&& s2) { + return Matcher, S1, S2>(binder, op, s1, s2); +} +template +inline decltype(auto) +AbstractBinaryOpMatcher(Binary** binder, Abstract::Op op, S1&& s1, S2&& s2) { + return Matcher, S1, S2>(binder, op, s1, s2); +} + +// Select +template<> struct NumComponents { static constexpr size_t value = 3; }; +template<> struct GetComponent { + Expression* operator()(Select* curr) { return curr->ifTrue; } +}; +template<> struct GetComponent { + Expression* operator()(Select* curr) { return curr->ifFalse; } +}; +template<> struct GetComponent { + Expression* operator()(Select* curr) { return curr->condition; } +}; +template +inline decltype(auto) +SelectMatcher(Select** binder, S1&& s1, S2&& s2, S3&& s3) { + return Matcher(binder, {}, s1, s2, s3); +} + +} // namespace Internal + +// Public matching API + +inline decltype(auto) i32() { + return Internal::ConstMatcher( + nullptr, Internal::I32Lit(nullptr, Internal::Any(nullptr))); +} +// Use int rather than int32_t to disambiguate literal 0, which otherwise could +// be resolved to either the int32_t overload or any of the pointer overloads. +inline decltype(auto) i32(int x) { + return Internal::ConstMatcher( + nullptr, Internal::I32Lit(nullptr, Internal::Exact(nullptr, x))); +} +inline decltype(auto) i32(int32_t* binder) { + return Internal::ConstMatcher( + nullptr, Internal::I32Lit(nullptr, Internal::Any(binder))); +} +inline decltype(auto) i32(Literal* binder) { + return Internal::ConstMatcher( + nullptr, Internal::I32Lit(binder, Internal::Any(nullptr))); +} +inline decltype(auto) i32(Const** binder) { + return Internal::ConstMatcher( + binder, Internal::I32Lit(nullptr, Internal::Any(nullptr))); +} + +inline decltype(auto) i64() { + return Internal::ConstMatcher( + nullptr, Internal::I64Lit(nullptr, Internal::Any(nullptr))); +} +inline decltype(auto) i64(int64_t x) { + return Internal::ConstMatcher( + nullptr, Internal::I64Lit(nullptr, Internal::Exact(nullptr, x))); +} +// Disambiguate literal 0, which could otherwise be interpreted as a pointer +inline decltype(auto) i64(int x) { return i64(int64_t(x)); } +inline decltype(auto) i64(int64_t* binder) { + return Internal::ConstMatcher( + nullptr, Internal::I64Lit(nullptr, Internal::Any(binder))); +} +inline decltype(auto) i64(Literal* binder) { + return Internal::ConstMatcher( + nullptr, Internal::I64Lit(binder, Internal::Any(nullptr))); +} +inline decltype(auto) i64(Const** binder) { + return Internal::ConstMatcher( + binder, Internal::I64Lit(nullptr, Internal::Any(nullptr))); +} + +inline decltype(auto) f32() { + return Internal::ConstMatcher( + nullptr, Internal::F32Lit(nullptr, Internal::Any(nullptr))); +} +inline decltype(auto) f32(float x) { + return Internal::ConstMatcher( + nullptr, Internal::F32Lit(nullptr, Internal::Exact(nullptr, x))); +} +// Disambiguate literal 0, which could otherwise be interpreted as a pointer +inline decltype(auto) f32(int x) { return f32(float(x)); } +inline decltype(auto) f32(float* binder) { + return Internal::ConstMatcher( + nullptr, Internal::F32Lit(nullptr, Internal::Any(binder))); +} +inline decltype(auto) f32(Literal* binder) { + return Internal::ConstMatcher( + nullptr, Internal::F32Lit(binder, Internal::Any(nullptr))); +} +inline decltype(auto) f32(Const** binder) { + return Internal::ConstMatcher( + binder, Internal::F32Lit(nullptr, Internal::Any(nullptr))); +} + +inline decltype(auto) f64() { + return Internal::ConstMatcher( + nullptr, Internal::F64Lit(nullptr, Internal::Any(nullptr))); +} +inline decltype(auto) f64(double x) { + return Internal::ConstMatcher( + nullptr, Internal::F64Lit(nullptr, Internal::Exact(nullptr, x))); +} +// Disambiguate literal 0, which could otherwise be interpreted as a pointer +inline decltype(auto) f64(int x) { return f64(double(x)); } +inline decltype(auto) f64(double* binder) { + return Internal::ConstMatcher( + nullptr, Internal::F64Lit(nullptr, Internal::Any(binder))); +} +inline decltype(auto) f64(Literal* binder) { + return Internal::ConstMatcher( + nullptr, Internal::F64Lit(binder, Internal::Any(nullptr))); +} +inline decltype(auto) f64(Const** binder) { + return Internal::ConstMatcher( + binder, Internal::F64Lit(nullptr, Internal::Any(nullptr))); +} + +inline decltype(auto) ival() { + return Internal::ConstMatcher( + nullptr, Internal::IntLit(nullptr, Internal::Any(nullptr))); +} +inline decltype(auto) ival(int64_t x) { + return Internal::ConstMatcher( + nullptr, Internal::IntLit(nullptr, Internal::Exact(nullptr, x))); +} +// Disambiguate literal 0, which could otherwise be interpreted as a pointer +inline decltype(auto) ival(int x) { return ival(int64_t(x)); } +inline decltype(auto) ival(int64_t* binder) { + return Internal::ConstMatcher( + nullptr, Internal::IntLit(nullptr, Internal::Any(binder))); +} +inline decltype(auto) ival(Literal* binder) { + return Internal::ConstMatcher( + nullptr, Internal::IntLit(binder, Internal::Any(nullptr))); +} +inline decltype(auto) ival(Const** binder) { + return Internal::ConstMatcher( + binder, Internal::IntLit(nullptr, Internal::Any(nullptr))); +} +inline decltype(auto) ival(Literal* binder, int64_t x) { + return Internal::ConstMatcher( + nullptr, Internal::IntLit(binder, Internal::Exact(nullptr, x))); +} +inline decltype(auto) ival(Const** binder, int64_t x) { + return Internal::ConstMatcher( + binder, Internal::IntLit(nullptr, Internal::Exact(nullptr, x))); +} + +inline decltype(auto) fval() { + return Internal::ConstMatcher( + nullptr, Internal::FloatLit(nullptr, Internal::Any(nullptr))); +} +inline decltype(auto) fval(double x) { + return Internal::ConstMatcher( + nullptr, Internal::FloatLit(nullptr, Internal::Exact(nullptr, x))); +} +// Disambiguate literal 0, which could otherwise be interpreted as a pointer +inline decltype(auto) fval(int x) { return fval(double(x)); } +inline decltype(auto) fval(double* binder) { + return Internal::ConstMatcher( + nullptr, Internal::FloatLit(nullptr, Internal::Any(binder))); +} +inline decltype(auto) fval(Literal* binder) { + return Internal::ConstMatcher( + nullptr, Internal::FloatLit(binder, Internal::Any(nullptr))); +} +inline decltype(auto) fval(Const** binder) { + return Internal::ConstMatcher( + binder, Internal::FloatLit(nullptr, Internal::Any(nullptr))); +} +inline decltype(auto) fval(Literal* binder, double x) { + return Internal::ConstMatcher( + nullptr, Internal::FloatLit(binder, Internal::Exact(nullptr, x))); +} +inline decltype(auto) fval(Const** binder, double x) { + return Internal::ConstMatcher( + binder, Internal::FloatLit(nullptr, Internal::Exact(nullptr, x))); +} + +inline decltype(auto) constant() { + return Internal::ConstMatcher(nullptr, Internal::Any(nullptr)); +} +inline decltype(auto) constant(int x) { + return Internal::ConstMatcher(nullptr, Internal::NumberLit(nullptr, x)); +} +inline decltype(auto) constant(Literal* binder) { + return Internal::ConstMatcher(nullptr, Internal::Any(binder)); +} +inline decltype(auto) constant(Const** binder) { + return Internal::ConstMatcher(binder, Internal::Any(nullptr)); +} +inline decltype(auto) constant(Literal* binder, int32_t x) { + return Internal::ConstMatcher(nullptr, Internal::NumberLit(binder, x)); +} +inline decltype(auto) constant(Const** binder, int32_t x) { + return Internal::ConstMatcher(binder, Internal::NumberLit(nullptr, x)); +} + +inline decltype(auto) any() { return Internal::Any(nullptr); } +inline decltype(auto) any(Expression** binder) { return Internal::Any(binder); } + +template inline decltype(auto) unary(S&& s) { + return Internal::UnaryMatcher(nullptr, Internal::Any(nullptr), s); +} +template inline decltype(auto) unary(Unary** binder, S&& s) { + return Internal::UnaryMatcher(binder, Internal::Any(nullptr), s); +} +template inline decltype(auto) unary(UnaryOp* binder, S&& s) { + return Internal::UnaryMatcher(nullptr, Internal::Any(binder), s); +} +template inline decltype(auto) unary(UnaryOp op, S&& s) { + return Internal::UnaryOpMatcher(nullptr, op, s); +} +template inline decltype(auto) unary(Abstract::Op op, S&& s) { + return Internal::AbstractUnaryOpMatcher(nullptr, op, s); +} +template +inline decltype(auto) unary(Unary** binder, UnaryOp op, S&& s) { + return Internal::UnaryOpMatcher(binder, op, s); +} +template +inline decltype(auto) unary(Unary** binder, Abstract::Op op, S&& s) { + return Internal::AbstractUnaryOpMatcher(binder, op, s); +} +template inline decltype(auto) binary(S1&& s1, S2&& s2) { + return Internal::BinaryMatcher( + nullptr, Internal::Any(nullptr), s1, s2); +} +template +inline decltype(auto) binary(Binary** binder, S1&& s1, S2&& s2) { + return Internal::BinaryMatcher( + binder, Internal::Any(nullptr), s1, s2); +} +template +inline decltype(auto) binary(BinaryOp* binder, S1&& s1, S2&& s2) { + return Internal::BinaryMatcher( + nullptr, Internal::Any(binder), s1, s2); +} +template +inline decltype(auto) binary(BinaryOp op, S1&& s1, S2&& s2) { + return Internal::BinaryOpMatcher(nullptr, op, s1, s2); +} +template +inline decltype(auto) binary(Abstract::Op op, S1&& s1, S2&& s2) { + return Internal::AbstractBinaryOpMatcher(nullptr, op, s1, s2); +} +template +inline decltype(auto) binary(Binary** binder, BinaryOp op, S1&& s1, S2&& s2) { + return Internal::BinaryOpMatcher(binder, op, s1, s2); +} +template +inline decltype(auto) +binary(Binary** binder, Abstract::Op op, S1&& s1, S2&& s2) { + return Internal::AbstractBinaryOpMatcher(binder, op, s1, s2); +} + +template +inline decltype(auto) select(S1&& s1, S2&& s2, S3&& s3) { + return Internal::SelectMatcher(nullptr, s1, s2, s3); +} +template +inline decltype(auto) select(Select** binder, S1&& s1, S2&& s2, S3&& s3) { + return Internal::SelectMatcher(binder, s1, s2, s3); +} + +} // namespace Match + +} // namespace wasm + +#endif // wasm_ir_match_h diff --git a/binaryen/src/ir/memory-utils.h b/binaryen/src/ir/memory-utils.h new file mode 100644 --- /dev/null +++ b/binaryen/src/ir/memory-utils.h @@ -0,0 +1,205 @@ +/* + * Copyright 2017 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef wasm_ir_memory_h +#define wasm_ir_memory_h + +#include +#include + +#include "literal.h" +#include "wasm-binary.h" +#include "wasm-builder.h" +#include "wasm.h" + +namespace wasm { + +namespace MemoryUtils { +// Flattens memory into a single data segment, or no segment. If there is +// a segment, it starts at 0. +// If ensuredSegmentSize is provided, then a segment is always emitted, +// and of at least that size. +// Returns true if successful (e.g. relocatable segments cannot be flattened). +inline bool flatten(Memory& memory, + Index ensuredSegmentSize = 0, + Module* module = nullptr) { + if (memory.segments.size() == 0) { + if (ensuredSegmentSize > 0) { + assert(module); // must provide a module if ensuring a size. + Builder builder(*module); + memory.segments.emplace_back(builder.makeConst(int32_t(0))); + memory.segments[0].data.resize(ensuredSegmentSize); + } + return true; + } + std::vector data; + data.resize(ensuredSegmentSize); + for (auto& segment : memory.segments) { + if (segment.isPassive) { + return false; + } + auto* offset = segment.offset->dynCast(); + if (!offset) { + return false; + } + } + for (auto& segment : memory.segments) { + auto* offset = segment.offset->dynCast(); + Index start = offset->value.getInteger(); + Index end = start + segment.data.size(); + if (end > data.size()) { + data.resize(end); + } + std::copy(segment.data.begin(), segment.data.end(), data.begin() + start); + } + memory.segments.resize(1); + memory.segments[0].offset->cast()->value = Literal(int32_t(0)); + memory.segments[0].data.swap(data); + return true; +} + +// Ensures that the memory exists (of minimal size). +inline void ensureExists(Memory& memory) { + if (!memory.exists) { + memory.exists = true; + memory.initial = memory.max = 1; + } +} + +// Try to merge segments until they fit into web limitations. +// Return true if successful. +inline bool ensureLimitedSegments(Module& module) { + Memory& memory = module.memory; + if (memory.segments.size() <= WebLimitations::MaxDataSegments) { + return true; + } + + // Conservatively refuse to change segments if there might be memory.init + // and data.drop instructions. + if (module.features.hasBulkMemory()) { + return false; + } + + auto isEmpty = [](Memory::Segment& segment) { + return segment.data.size() == 0; + }; + + auto isConstantOffset = [](Memory::Segment& segment) { + return segment.offset && segment.offset->is(); + }; + + Index numConstant = 0, numDynamic = 0; + bool hasPassiveSegments = false; + for (auto& segment : memory.segments) { + if (!isEmpty(segment)) { + if (isConstantOffset(segment)) { + numConstant++; + } else { + numDynamic++; + } + } + hasPassiveSegments |= segment.isPassive; + } + + if (hasPassiveSegments) { + return false; + } + + // check if we have too many dynamic data segments, which we can do nothing + // about + if (numDynamic + 1 >= WebLimitations::MaxDataSegments) { + return false; + } + + // we'll merge constant segments if we must + if (numConstant + numDynamic >= WebLimitations::MaxDataSegments) { + numConstant = WebLimitations::MaxDataSegments - numDynamic - 1; + auto num = numConstant + numDynamic; + WASM_UNUSED(num); + assert(num == WebLimitations::MaxDataSegments - 1); + } + + std::vector mergedSegments; + mergedSegments.reserve(WebLimitations::MaxDataSegments); + + // drop empty segments and pass through dynamic-offset segments + for (auto& segment : memory.segments) { + if (isEmpty(segment)) { + continue; + } + if (isConstantOffset(segment)) { + continue; + } + mergedSegments.push_back(segment); + } + + // from here on, we concern ourselves with non-empty constant-offset + // segments, the ones which we may need to merge + auto isRelevant = [&](Memory::Segment& segment) { + return !isEmpty(segment) && isConstantOffset(segment); + }; + for (Index i = 0; i < memory.segments.size(); i++) { + auto& segment = memory.segments[i]; + if (!isRelevant(segment)) { + continue; + } + if (mergedSegments.size() + 2 < WebLimitations::MaxDataSegments) { + mergedSegments.push_back(segment); + continue; + } + // we can emit only one more segment! merge everything into one + // start the combined segment at the bottom of them all + auto start = segment.offset->cast()->value.getInteger(); + for (Index j = i + 1; j < memory.segments.size(); j++) { + auto& segment = memory.segments[j]; + if (!isRelevant(segment)) { + continue; + } + auto offset = segment.offset->cast()->value.getInteger(); + start = std::min(start, offset); + } + // create the segment and add in all the data + auto* c = module.allocator.alloc(); + c->value = Literal(int32_t(start)); + c->type = Type::i32; + + Memory::Segment combined(c); + for (Index j = i; j < memory.segments.size(); j++) { + auto& segment = memory.segments[j]; + if (!isRelevant(segment)) { + continue; + } + auto offset = segment.offset->cast()->value.getInteger(); + auto needed = offset + segment.data.size() - start; + if (combined.data.size() < needed) { + combined.data.resize(needed); + } + std::copy(segment.data.begin(), + segment.data.end(), + combined.data.begin() + (offset - start)); + } + mergedSegments.push_back(combined); + break; + } + + memory.segments.swap(mergedSegments); + return true; +} +} // namespace MemoryUtils + +} // namespace wasm + +#endif // wasm_ir_memory_h diff --git a/binaryen/src/ir/module-utils.h b/binaryen/src/ir/module-utils.h new file mode 100644 --- /dev/null +++ b/binaryen/src/ir/module-utils.h @@ -0,0 +1,464 @@ +/* + * Copyright 2017 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef wasm_ir_module_h +#define wasm_ir_module_h + +#include "ir/find_all.h" +#include "ir/manipulation.h" +#include "ir/properties.h" +#include "pass.h" +#include "support/unique_deferring_queue.h" +#include "wasm.h" + +namespace wasm { + +namespace ModuleUtils { + +inline Function* copyFunction(Function* func, Module& out) { + auto* ret = new Function(); + ret->name = func->name; + ret->sig = func->sig; + ret->vars = func->vars; + ret->localNames = func->localNames; + ret->localIndices = func->localIndices; + ret->debugLocations = func->debugLocations; + ret->body = ExpressionManipulator::copy(func->body, out); + ret->module = func->module; + ret->base = func->base; + // TODO: copy Stack IR + assert(!func->stackIR); + out.addFunction(ret); + return ret; +} + +inline Global* copyGlobal(Global* global, Module& out) { + auto* ret = new Global(); + ret->name = global->name; + ret->type = global->type; + ret->mutable_ = global->mutable_; + ret->module = global->module; + ret->base = global->base; + if (global->imported()) { + ret->init = nullptr; + } else { + ret->init = ExpressionManipulator::copy(global->init, out); + } + out.addGlobal(ret); + return ret; +} + +inline Event* copyEvent(Event* event, Module& out) { + auto* ret = new Event(); + ret->name = event->name; + ret->attribute = event->attribute; + ret->sig = event->sig; + out.addEvent(ret); + return ret; +} + +inline void copyModule(const Module& in, Module& out) { + // we use names throughout, not raw pointers, so simple copying is fine + // for everything *but* expressions + for (auto& curr : in.exports) { + out.addExport(new Export(*curr)); + } + for (auto& curr : in.functions) { + copyFunction(curr.get(), out); + } + for (auto& curr : in.globals) { + copyGlobal(curr.get(), out); + } + for (auto& curr : in.events) { + copyEvent(curr.get(), out); + } + out.table = in.table; + for (auto& segment : out.table.segments) { + segment.offset = ExpressionManipulator::copy(segment.offset, out); + } + out.memory = in.memory; + for (auto& segment : out.memory.segments) { + segment.offset = ExpressionManipulator::copy(segment.offset, out); + } + out.start = in.start; + out.userSections = in.userSections; + out.debugInfoFileNames = in.debugInfoFileNames; +} + +inline void clearModule(Module& wasm) { + wasm.~Module(); + new (&wasm) Module; +} + +// Renaming + +// Rename functions along with all their uses. +// Note that for this to work the functions themselves don't necessarily need +// to exist. For example, it is possible to remove a given function and then +// call this redirect all of its uses. +template inline void renameFunctions(Module& wasm, T& map) { + // Update the function itself. + for (auto& pair : map) { + if (Function* F = wasm.getFunctionOrNull(pair.first)) { + assert(!wasm.getFunctionOrNull(pair.second) || F->name == pair.second); + F->name = pair.second; + } + } + wasm.updateMaps(); + // Update other global things. + auto maybeUpdate = [&](Name& name) { + auto iter = map.find(name); + if (iter != map.end()) { + name = iter->second; + } + }; + maybeUpdate(wasm.start); + for (auto& segment : wasm.table.segments) { + for (auto& name : segment.data) { + maybeUpdate(name); + } + } + for (auto& exp : wasm.exports) { + if (exp->kind == ExternalKind::Function) { + maybeUpdate(exp->value); + } + } + // Update call instructions. + for (auto& func : wasm.functions) { + // TODO: parallelize + if (!func->imported()) { + FindAll calls(func->body); + for (auto* call : calls.list) { + maybeUpdate(call->target); + } + } + } +} + +inline void renameFunction(Module& wasm, Name oldName, Name newName) { + std::map map; + map[oldName] = newName; + renameFunctions(wasm, map); +} + +// Convenient iteration over imported/non-imported module elements + +template inline void iterImportedMemories(Module& wasm, T visitor) { + if (wasm.memory.exists && wasm.memory.imported()) { + visitor(&wasm.memory); + } +} + +template inline void iterDefinedMemories(Module& wasm, T visitor) { + if (wasm.memory.exists && !wasm.memory.imported()) { + visitor(&wasm.memory); + } +} + +template inline void iterImportedTables(Module& wasm, T visitor) { + if (wasm.table.exists && wasm.table.imported()) { + visitor(&wasm.table); + } +} + +template inline void iterDefinedTables(Module& wasm, T visitor) { + if (wasm.table.exists && !wasm.table.imported()) { + visitor(&wasm.table); + } +} + +template inline void iterImportedGlobals(Module& wasm, T visitor) { + for (auto& import : wasm.globals) { + if (import->imported()) { + visitor(import.get()); + } + } +} + +template inline void iterDefinedGlobals(Module& wasm, T visitor) { + for (auto& import : wasm.globals) { + if (!import->imported()) { + visitor(import.get()); + } + } +} + +template +inline void iterImportedFunctions(Module& wasm, T visitor) { + for (auto& import : wasm.functions) { + if (import->imported()) { + visitor(import.get()); + } + } +} + +template inline void iterDefinedFunctions(Module& wasm, T visitor) { + for (auto& import : wasm.functions) { + if (!import->imported()) { + visitor(import.get()); + } + } +} + +template inline void iterImportedEvents(Module& wasm, T visitor) { + for (auto& import : wasm.events) { + if (import->imported()) { + visitor(import.get()); + } + } +} + +template inline void iterDefinedEvents(Module& wasm, T visitor) { + for (auto& import : wasm.events) { + if (!import->imported()) { + visitor(import.get()); + } + } +} + +template inline void iterImports(Module& wasm, T visitor) { + iterImportedMemories(wasm, visitor); + iterImportedTables(wasm, visitor); + iterImportedGlobals(wasm, visitor); + iterImportedFunctions(wasm, visitor); + iterImportedEvents(wasm, visitor); +} + +// Helper class for performing an operation on all the functions in the module, +// in parallel, with an Info object for each one that can contain results of +// some computation that the operation performs. +// The operation performend should not modify the wasm module in any way. +// TODO: enforce this +template struct ParallelFunctionAnalysis { + Module& wasm; + + typedef std::map Map; + Map map; + + typedef std::function Func; + + ParallelFunctionAnalysis(Module& wasm, Func work) : wasm(wasm) { + // Fill in map, as we operate on it in parallel (each function to its own + // entry). + for (auto& func : wasm.functions) { + map[func.get()]; + } + + // Run on the imports first. TODO: parallelize this too + for (auto& func : wasm.functions) { + if (func->imported()) { + work(func.get(), map[func.get()]); + } + } + + struct Mapper : public WalkerPass> { + bool isFunctionParallel() override { return true; } + bool modifiesBinaryenIR() override { return false; } + + Mapper(Module& module, Map& map, Func work) + : module(module), map(map), work(work) {} + + Mapper* create() override { return new Mapper(module, map, work); } + + void doWalkFunction(Function* curr) { + assert(map.count(curr)); + work(curr, map[curr]); + } + + private: + Module& module; + Map& map; + Func work; + }; + + PassRunner runner(&wasm); + Mapper(wasm, map, work).run(&runner, &wasm); + } +}; + +// Helper class for analyzing the call graph. +// +// Provides hooks for running some initial calculation on each function (which +// is done in parallel), writing to a FunctionInfo structure for each function. +// Then you can call propagateBack() to propagate a property of interest to the +// calling functions, transitively. +// +// For example, if some functions are known to call an import "foo", then you +// can use this to find which functions call something that might eventually +// reach foo, by initially marking the direct callers as "calling foo" and +// propagating that backwards. +template struct CallGraphPropertyAnalysis { + Module& wasm; + + // The basic information for each function about whom it calls and who is + // called by it. + struct FunctionInfo { + std::set callsTo; + std::set calledBy; + bool hasIndirectCall = false; + }; + + typedef std::map Map; + Map map; + + typedef std::function Func; + + CallGraphPropertyAnalysis(Module& wasm, Func work) : wasm(wasm) { + ParallelFunctionAnalysis analysis(wasm, [&](Function* func, T& info) { + work(func, info); + if (func->imported()) { + return; + } + struct Mapper : public PostWalker { + Mapper(Module* module, T& info, Func work) + : module(module), info(info), work(work) {} + + void visitCall(Call* curr) { + info.callsTo.insert(module->getFunction(curr->target)); + } + + void visitCallIndirect(CallIndirect* curr) { + info.hasIndirectCall = true; + } + + private: + Module* module; + T& info; + Func work; + } mapper(&wasm, info, work); + mapper.walk(func->body); + }); + + map.swap(analysis.map); + + // Find what is called by what. + for (auto& pair : map) { + auto* func = pair.first; + auto& info = pair.second; + for (auto* target : info.callsTo) { + map[target].calledBy.insert(func); + } + } + } + + enum IndirectCalls { IgnoreIndirectCalls, IndirectCallsHaveProperty }; + + // Propagate a property from a function to those that call it. + // + // hasProperty() - Check if the property is present. + // canHaveProperty() - Check if the property could be present. + // addProperty() - Adds the property. This receives a second parameter which + // is the function due to which we are adding the property. + void propagateBack(std::function hasProperty, + std::function canHaveProperty, + std::function addProperty, + IndirectCalls indirectCalls) { + // The work queue contains items we just learned can change the state. + UniqueDeferredQueue work; + for (auto& func : wasm.functions) { + if (hasProperty(map[func.get()]) || + (indirectCalls == IndirectCallsHaveProperty && + map[func.get()].hasIndirectCall)) { + addProperty(map[func.get()], func.get()); + work.push(func.get()); + } + } + while (!work.empty()) { + auto* func = work.pop(); + for (auto* caller : map[func].calledBy) { + // If we don't already have the property, and we are not forbidden + // from getting it, then it propagates back to us now. + if (!hasProperty(map[caller]) && canHaveProperty(map[caller])) { + addProperty(map[caller], func); + work.push(caller); + } + } + } + } +}; + +// Helper function for collecting the type signatures used in a module +// +// Used when emitting or printing a module to give signatures canonical +// indices. Signatures are sorted in order of decreasing frequency to minize the +// size of their collective encoding. Both a vector mapping indices to +// signatures and a map mapping signatures to indices are produced. +inline void +collectSignatures(Module& wasm, + std::vector& signatures, + std::unordered_map& sigIndices) { + using Counts = std::unordered_map; + + // Collect the signature use counts for a single function + auto updateCounts = [&](Function* func, Counts& counts) { + if (func->imported()) { + return; + } + struct TypeCounter + : PostWalker> { + Counts& counts; + + TypeCounter(Counts& counts) : counts(counts) {} + void visitExpression(Expression* curr) { + if (auto* call = curr->dynCast()) { + counts[call->sig]++; + } else if (Properties::isControlFlowStructure(curr)) { + // TODO: Allow control flow to have input types as well + if (curr->type.isTuple()) { + counts[Signature(Type::none, curr->type)]++; + } + } + } + }; + TypeCounter(counts).walk(func->body); + }; + + ModuleUtils::ParallelFunctionAnalysis analysis(wasm, updateCounts); + + // Collect all the counts. + Counts counts; + for (auto& curr : wasm.functions) { + counts[curr->sig]++; + } + for (auto& curr : wasm.events) { + counts[curr->sig]++; + } + for (auto& pair : analysis.map) { + Counts& functionCounts = pair.second; + for (auto& innerPair : functionCounts) { + counts[innerPair.first] += innerPair.second; + } + } + std::vector> sorted(counts.begin(), + counts.end()); + std::sort(sorted.begin(), sorted.end(), [&](auto a, auto b) { + // order by frequency then simplicity + if (a.second != b.second) { + return a.second > b.second; + } + return a.first < b.first; + }); + for (Index i = 0; i < sorted.size(); ++i) { + sigIndices[sorted[i].first] = i; + signatures.push_back(sorted[i].first); + } +} + +} // namespace ModuleUtils + +} // namespace wasm + +#endif // wasm_ir_module_h diff --git a/binaryen/src/ir/names.h b/binaryen/src/ir/names.h new file mode 100644 --- /dev/null +++ b/binaryen/src/ir/names.h @@ -0,0 +1,53 @@ +/* + * Copyright 2017 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef wasm_ir_names_h +#define wasm_ir_names_h + +#include "wasm.h" + +namespace wasm { + +namespace Names { + +// Add explicit names for function locals not yet named, and do not +// modify existing names +inline void ensureNames(Function* func) { + std::unordered_set seen; + for (auto& pair : func->localNames) { + seen.insert(pair.second); + } + Index nameIndex = seen.size(); + for (Index i = 0; i < func->getNumLocals(); i++) { + if (!func->hasLocalName(i)) { + while (1) { + auto name = Name::fromInt(nameIndex++); + if (seen.count(name) == 0) { + func->localNames[i] = name; + func->localIndices[name] = i; + seen.insert(name); + break; + } + } + } + } +} + +} // namespace Names + +} // namespace wasm + +#endif // wasm_ir_names_h diff --git a/binaryen/src/ir/parents.h b/binaryen/src/ir/parents.h new file mode 100644 --- /dev/null +++ b/binaryen/src/ir/parents.h @@ -0,0 +1,38 @@ +/* + * Copyright 2019 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef wasm_ir_parents_h +#define wasm_ir_parents_h + +namespace wasm { + +struct Parents { + Parents(Expression* expr) { inner.walk(expr); } + + Expression* getParent(Expression* curr) { return inner.parentMap[curr]; } + +private: + struct Inner + : public ExpressionStackWalker> { + void visitExpression(Expression* curr) { parentMap[curr] = getParent(); } + + std::map parentMap; + } inner; +}; + +} // namespace wasm + +#endif // wasm_ir_parents_h diff --git a/binaryen/src/ir/properties.h b/binaryen/src/ir/properties.h new file mode 100644 --- /dev/null +++ b/binaryen/src/ir/properties.h @@ -0,0 +1,281 @@ +/* + * Copyright 2016 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef wasm_ir_properties_h +#define wasm_ir_properties_h + +#include "ir/bits.h" +#include "ir/effects.h" +#include "wasm.h" + +namespace wasm { + +namespace Properties { + +inline bool emitsBoolean(Expression* curr) { + if (auto* unary = curr->dynCast()) { + return unary->isRelational(); + } else if (auto* binary = curr->dynCast()) { + return binary->isRelational(); + } + return false; +} + +inline bool isSymmetric(Binary* binary) { + switch (binary->op) { + case AddInt32: + case MulInt32: + case AndInt32: + case OrInt32: + case XorInt32: + case EqInt32: + case NeInt32: + + case AddInt64: + case MulInt64: + case AndInt64: + case OrInt64: + case XorInt64: + case EqInt64: + case NeInt64: + + case EqFloat32: + case NeFloat32: + case EqFloat64: + case NeFloat64: + return true; + + default: + return false; + } +} + +inline bool isControlFlowStructure(Expression* curr) { + return curr->is() || curr->is() || curr->is() || + curr->is(); +} + +// Check if an expression is a control flow construct with a name, +// which implies it may have breaks to it. +inline bool isNamedControlFlow(Expression* curr) { + if (auto* block = curr->dynCast()) { + return block->name.is(); + } else if (auto* loop = curr->dynCast()) { + return loop->name.is(); + } + return false; +} + +inline bool isSingleConstantExpression(const Expression* curr) { + return curr->is() || curr->is() || curr->is() || + (curr->is() && curr->cast()->value->is()); +} + +inline bool isConstantExpression(const Expression* curr) { + if (isSingleConstantExpression(curr)) { + return true; + } + if (auto* tuple = curr->dynCast()) { + for (auto* op : tuple->operands) { + if (!isSingleConstantExpression(op)) { + return false; + } + } + return true; + } + return false; +} + +inline Literal getLiteral(const Expression* curr) { + if (auto* c = curr->dynCast()) { + return c->value; + } else if (auto* n = curr->dynCast()) { + return Literal(n->type); + } else if (auto* r = curr->dynCast()) { + return Literal(r->func); + } else if (auto* i = curr->dynCast()) { + if (auto* c = i->value->dynCast()) { + return Literal::makeI31(c->value.geti32()); + } + } + WASM_UNREACHABLE("non-constant expression"); +} + +inline Literals getLiterals(const Expression* curr) { + if (isSingleConstantExpression(curr)) { + return {getLiteral(curr)}; + } else if (auto* tuple = curr->dynCast()) { + Literals literals; + for (auto* op : tuple->operands) { + literals.push_back(getLiteral(op)); + } + return literals; + } else { + WASM_UNREACHABLE("non-constant expression"); + } +} + +// Check if an expression is a sign-extend, and if so, returns the value +// that is extended, otherwise nullptr +inline Expression* getSignExtValue(Expression* curr) { + if (auto* outer = curr->dynCast()) { + if (outer->op == ShrSInt32) { + if (auto* outerConst = outer->right->dynCast()) { + if (outerConst->value.geti32() != 0) { + if (auto* inner = outer->left->dynCast()) { + if (inner->op == ShlInt32) { + if (auto* innerConst = inner->right->dynCast()) { + if (outerConst->value == innerConst->value) { + return inner->left; + } + } + } + } + } + } + } + } + return nullptr; +} + +// gets the size of the sign-extended value +inline Index getSignExtBits(Expression* curr) { + return 32 - Bits::getEffectiveShifts(curr->cast()->right); +} + +// Check if an expression is almost a sign-extend: perhaps the inner shift +// is too large. We can split the shifts in that case, which is sometimes +// useful (e.g. if we can remove the signext) +inline Expression* getAlmostSignExt(Expression* curr) { + if (auto* outer = curr->dynCast()) { + if (outer->op == ShrSInt32) { + if (auto* outerConst = outer->right->dynCast()) { + if (outerConst->value.geti32() != 0) { + if (auto* inner = outer->left->dynCast()) { + if (inner->op == ShlInt32) { + if (auto* innerConst = inner->right->dynCast()) { + if (Bits::getEffectiveShifts(outerConst) <= + Bits::getEffectiveShifts(innerConst)) { + return inner->left; + } + } + } + } + } + } + } + } + return nullptr; +} + +// gets the size of the almost sign-extended value, as well as the +// extra shifts, if any +inline Index getAlmostSignExtBits(Expression* curr, Index& extraShifts) { + extraShifts = Bits::getEffectiveShifts( + curr->cast()->left->cast()->right) - + Bits::getEffectiveShifts(curr->cast()->right); + return getSignExtBits(curr); +} + +// Check if an expression is a zero-extend, and if so, returns the value +// that is extended, otherwise nullptr +inline Expression* getZeroExtValue(Expression* curr) { + if (auto* binary = curr->dynCast()) { + if (binary->op == AndInt32) { + if (auto* c = binary->right->dynCast()) { + if (Bits::getMaskedBits(c->value.geti32())) { + return binary->right; + } + } + } + } + return nullptr; +} + +// gets the size of the sign-extended value +inline Index getZeroExtBits(Expression* curr) { + return Bits::getMaskedBits( + curr->cast()->right->cast()->value.geti32()); +} + +// Returns a falling-through value, that is, it looks through a local.tee +// and other operations that receive a value and let it flow through them. If +// there is no value falling through, returns the node itself (as that is the +// value that trivially falls through, with 0 steps in the middle). +inline Expression* getFallthrough(Expression* curr, + const PassOptions& passOptions, + FeatureSet features) { + // If the current node is unreachable, there is no value + // falling through. + if (curr->type == Type::unreachable) { + return curr; + } + if (auto* set = curr->dynCast()) { + if (set->isTee()) { + return getFallthrough(set->value, passOptions, features); + } + } else if (auto* block = curr->dynCast()) { + // if no name, we can't be broken to, and then can look at the fallthrough + if (!block->name.is() && block->list.size() > 0) { + return getFallthrough(block->list.back(), passOptions, features); + } + } else if (auto* loop = curr->dynCast()) { + return getFallthrough(loop->body, passOptions, features); + } else if (auto* iff = curr->dynCast()) { + if (iff->ifFalse) { + // Perhaps just one of the two actually returns. + if (iff->ifTrue->type == Type::unreachable) { + return getFallthrough(iff->ifFalse, passOptions, features); + } else if (iff->ifFalse->type == Type::unreachable) { + return getFallthrough(iff->ifTrue, passOptions, features); + } + } + } else if (auto* br = curr->dynCast()) { + if (br->condition && br->value) { + return getFallthrough(br->value, passOptions, features); + } + } else if (auto* tryy = curr->dynCast()) { + if (!EffectAnalyzer(passOptions, features, tryy->body).throws) { + return getFallthrough(tryy->body, passOptions, features); + } + } + return curr; +} + +// Returns whether the resulting value here must fall through without being +// modified. For example, a tee always does so. That is, this returns false if +// and only if the return value may have some computation performed on it to +// change it from the inputs the instruction receives. +// This differs from getFallthrough() which returns a single value that falls +// through - here if more than one value can fall through, like in if-else, +// we can return true. That is, there we care about a value falling through and +// for us to get that actual value to look at; here we just care whether the +// value falls through without being changed, even if it might be one of +// several options. +inline bool isResultFallthrough(Expression* curr) { + // Note that we don't check if there is a return value here; the node may be + // unreachable, for example, but then there is no meaningful answer to give + // anyhow. + return curr->is() || curr->is() || curr->is() || + curr->is() || curr->is() || curr->is()) { + if (index == 0) { + return &select->condition; + } else if (index == 1) { + return &select->ifTrue; + } else if (index == 2) { + return &select->ifFalse; + } + WASM_UNREACHABLE("unexpected index"); + } + WASM_UNREACHABLE("unexpected expression type"); + } +}; + +Pass* createDataFlowOptsPass() { return new DataFlowOpts(); } + +} // namespace wasm diff --git a/binaryen/src/passes/DeAlign.cpp b/binaryen/src/passes/DeAlign.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/passes/DeAlign.cpp @@ -0,0 +1,41 @@ +/* + * Copyright 2020 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// Forces all loads and stores to be completely unaligned, that is, to have +// alignment 1. +// + +#include "pass.h" +#include "wasm.h" + +namespace wasm { + +struct DeAlign : public WalkerPass> { + bool isFunctionParallel() override { return true; } + + Pass* create() override { return new DeAlign(); } + + void visitLoad(Load* curr) { curr->align = 1; } + + void visitStore(Store* curr) { curr->align = 1; } + + void visitSIMDLoad(SIMDLoad* curr) { curr->align = 1; } +}; + +Pass* createDeAlignPass() { return new DeAlign(); } + +} // namespace wasm diff --git a/binaryen/src/passes/DeNaN.cpp b/binaryen/src/passes/DeNaN.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/passes/DeNaN.cpp @@ -0,0 +1,140 @@ +/* + * Copyright 2020 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// Instrument the wasm to convert NaN values at runtime into 0s. That is, every +// operation that might produce a NaN will go through a helper function which +// filters out NaNs (replacing them with 0). This ensures that NaNs are never +// consumed by any instructions, which is useful when fuzzing between VMs that +// differ on wasm's nondeterminism around NaNs. +// + +#include "ir/properties.h" +#include "pass.h" +#include "wasm-builder.h" +#include "wasm.h" + +namespace wasm { + +struct DeNaN : public WalkerPass< + ControlFlowWalker>> { + void visitExpression(Expression* expr) { + // If the expression returns a floating-point value, ensure it is not a + // NaN. If we can do this at compile time, do it now, which is useful for + // initializations of global (which we can't do a function call in). Note + // that we don't instrument local.gets, which would cause problems if we + // ran this pass more than once (the added functions use gets, and we don't + // want to instrument them). + if (expr->is()) { + return; + } + // If the result just falls through without being modified, then we've + // already fixed it up earlier. + if (Properties::isResultFallthrough(expr)) { + return; + } + Builder builder(*getModule()); + Expression* replacement = nullptr; + auto* c = expr->dynCast(); + if (expr->type == Type::f32) { + if (c && c->value.isNaN()) { + replacement = builder.makeConst(float(0)); + } else { + replacement = builder.makeCall("deNan32", {expr}, Type::f32); + } + } else if (expr->type == Type::f64) { + if (c && c->value.isNaN()) { + replacement = builder.makeConst(double(0)); + } else { + replacement = builder.makeCall("deNan64", {expr}, Type::f64); + } + } + if (replacement) { + // We can't do this outside of a function, like in a global initializer, + // where a call would be illegal. + if (replacement->is() || getFunction()) { + replaceCurrent(replacement); + } else { + std::cerr << "warning: cannot de-nan outside of function context\n"; + } + } + } + + void visitFunction(Function* func) { + if (func->imported()) { + return; + } + // Instrument all locals as they enter the function. + Builder builder(*getModule()); + std::vector fixes; + auto num = func->getNumParams(); + for (Index i = 0; i < num; i++) { + if (func->getLocalType(i) == Type::f32) { + fixes.push_back(builder.makeLocalSet( + i, + builder.makeCall( + "deNan32", {builder.makeLocalGet(i, Type::f32)}, Type::f32))); + } else if (func->getLocalType(i) == Type::f64) { + fixes.push_back(builder.makeLocalSet( + i, + builder.makeCall( + "deNan64", {builder.makeLocalGet(i, Type::f64)}, Type::f64))); + } + } + if (!fixes.empty()) { + fixes.push_back(func->body); + func->body = builder.makeBlock(fixes); + // Merge blocks so we don't add an unnecessary one. + PassRunner runner(getModule(), getPassOptions()); + runner.setIsNested(true); + runner.add("merge-blocks"); + runner.run(); + } + } + + void visitModule(Module* module) { + // Add helper functions. + Builder builder(*module); + auto add = [&](Name name, Type type, Literal literal, BinaryOp op) { + auto* func = new Function; + func->name = name; + func->sig = Signature(type, type); + // Compare the value to itself to check if it is a NaN, and return 0 if + // so: + // + // (if (result f*) + // (f*.eq + // (local.get $0) + // (local.get $0) + // ) + // (local.get $0) + // (f*.const 0) + // ) + func->body = builder.makeIf( + builder.makeBinary( + op, builder.makeLocalGet(0, type), builder.makeLocalGet(0, type)), + builder.makeLocalGet(0, type), + builder.makeConst(literal)); + module->addFunction(func); + }; + add("deNan32", Type::f32, Literal(float(0)), EqFloat32); + add("deNan64", Type::f64, Literal(double(0)), EqFloat64); + } +}; + +Pass* createDeNaNPass() { return new DeNaN(); } + +} // namespace wasm diff --git a/binaryen/src/passes/DeadArgumentElimination.cpp b/binaryen/src/passes/DeadArgumentElimination.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/passes/DeadArgumentElimination.cpp @@ -0,0 +1,485 @@ +/* + * Copyright 2018 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// Optimizes call arguments in a whole-program manner, removing ones +// that are not used (dead). +// +// Specifically, this does these things: +// +// * Find functions for whom an argument is always passed the same +// constant. If so, we can just set that local to that constant +// in the function. +// * Find functions that don't use the value passed to an argument. +// If so, we can avoid even sending and receiving it. (Note how if +// the previous point was true for an argument, then the second +// must as well.) +// * Find return values ("return arguments" ;) that are never used. +// +// This pass does not depend on flattening, but it may be more effective, +// as then call arguments never have side effects (which we need to +// watch for here). +// + +#include +#include + +#include "cfg/cfg-traversal.h" +#include "ir/effects.h" +#include "ir/module-utils.h" +#include "pass.h" +#include "passes/opt-utils.h" +#include "support/sorted_vector.h" +#include "wasm-builder.h" +#include "wasm.h" + +namespace wasm { + +// Information for a function +struct DAEFunctionInfo { + // The unused parameters, if any. + SortedVector unusedParams; + // Maps a function name to the calls going to it. + std::unordered_map> calls; + // Map of all calls that are dropped, to their drops' locations (so that + // if we can optimize out the drop, we can replace the drop there). + std::unordered_map droppedCalls; + // Whether this function contains any tail calls (including indirect tail + // calls) and the set of functions this function tail calls. Tail-callers and + // tail-callees cannot have their dropped returns removed because of the + // constraint that tail-callees must have the same return type as + // tail-callers. Indirectly tail called functions are already not optimized + // because being in a table inhibits DAE. TODO: Allow the removal of dropped + // returns from tail-callers if their tail-callees can have their returns + // removed as well. + bool hasTailCalls = false; + std::unordered_set tailCallees; + // Whether the function can be called from places that + // affect what we can do. For now, any call we don't + // see inhibits our optimizations, but TODO: an export + // could be worked around by exporting a thunk that + // adds the parameter. + bool hasUnseenCalls = false; +}; + +typedef std::unordered_map DAEFunctionInfoMap; + +// Information in a basic block +struct DAEBlockInfo { + // A local may be read, written, or not accessed in this block. + // If it is both read and written, we just care about the first + // action (if it is read first, that's all the info we are + // looking for; if it is written first, it can't be read later). + enum LocalUse { Read, Written }; + std::unordered_map localUses; +}; + +struct DAEScanner + : public WalkerPass< + CFGWalker, DAEBlockInfo>> { + bool isFunctionParallel() override { return true; } + + Pass* create() override { return new DAEScanner(infoMap); } + + DAEScanner(DAEFunctionInfoMap* infoMap) : infoMap(infoMap) {} + + DAEFunctionInfoMap* infoMap; + DAEFunctionInfo* info; + + Index numParams; + + // cfg traversal work + + void visitLocalGet(LocalGet* curr) { + if (currBasicBlock) { + auto& localUses = currBasicBlock->contents.localUses; + auto index = curr->index; + if (localUses.count(index) == 0) { + localUses[index] = DAEBlockInfo::Read; + } + } + } + + void visitLocalSet(LocalSet* curr) { + if (currBasicBlock) { + auto& localUses = currBasicBlock->contents.localUses; + auto index = curr->index; + if (localUses.count(index) == 0) { + localUses[index] = DAEBlockInfo::Written; + } + } + } + + void visitCall(Call* curr) { + if (!getModule()->getFunction(curr->target)->imported()) { + info->calls[curr->target].push_back(curr); + } + if (curr->isReturn) { + info->hasTailCalls = true; + info->tailCallees.insert(curr->target); + } + } + + void visitCallIndirect(CallIndirect* curr) { + if (curr->isReturn) { + info->hasTailCalls = true; + } + } + + void visitDrop(Drop* curr) { + if (auto* call = curr->value->dynCast()) { + info->droppedCalls[call] = getCurrentPointer(); + } + } + + // main entry point + + void doWalkFunction(Function* func) { + numParams = func->getNumParams(); + info = &((*infoMap)[func->name]); + CFGWalker, DAEBlockInfo>::doWalkFunction( + func); + // If there are relevant params, check if they are used. (If + // we can't optimize the function anyhow, there's no point.) + if (numParams > 0 && !info->hasUnseenCalls) { + findUnusedParams(func); + } + } + + void findUnusedParams(Function* func) { + // Flow the incoming parameter values, see if they reach a read. + // Once we've seen a parameter at a block, we need never consider it there + // again. + std::unordered_map seenBlockIndexes; + // Start with all the incoming parameters. + SortedVector initial; + for (Index i = 0; i < numParams; i++) { + initial.push_back(i); + } + // The used params, which we now compute. + std::unordered_set usedParams; + // An item of work is a block plus the values arriving there. + typedef std::pair Item; + std::vector work; + work.emplace_back(entry, initial); + while (!work.empty()) { + auto item = std::move(work.back()); + work.pop_back(); + auto* block = item.first; + auto& indexes = item.second; + // Ignore things we've already seen, or we've already seen to be used. + auto& seenIndexes = seenBlockIndexes[block]; + indexes.filter([&](const Index i) { + if (seenIndexes.has(i) || usedParams.count(i)) { + return false; + } else { + seenIndexes.insert(i); + return true; + } + }); + if (indexes.empty()) { + continue; // nothing more to flow + } + auto& localUses = block->contents.localUses; + SortedVector remainingIndexes; + for (auto i : indexes) { + auto iter = localUses.find(i); + if (iter != localUses.end()) { + auto use = iter->second; + if (use == DAEBlockInfo::Read) { + usedParams.insert(i); + } + // Whether it was a read or a write, we can stop looking at that local + // here. + } else { + remainingIndexes.insert(i); + } + } + // If there are remaining indexes, flow them forward. + if (!remainingIndexes.empty()) { + for (auto* next : block->out) { + work.emplace_back(next, remainingIndexes); + } + } + } + // We can now compute the unused params. + for (Index i = 0; i < numParams; i++) { + if (usedParams.count(i) == 0) { + info->unusedParams.insert(i); + } + } + } +}; + +struct DAE : public Pass { + bool optimize = false; + + void run(PassRunner* runner, Module* module) override { + // Iterate to convergence. + while (1) { + if (!iteration(runner, module)) { + break; + } + } + } + + bool iteration(PassRunner* runner, Module* module) { + allDroppedCalls.clear(); + + DAEFunctionInfoMap infoMap; + // Ensure they all exist so the parallel threads don't modify the data + // structure. + ModuleUtils::iterDefinedFunctions( + *module, [&](Function* func) { infoMap[func->name]; }); + // Check the influence of the table and exports. + for (auto& curr : module->exports) { + if (curr->kind == ExternalKind::Function) { + infoMap[curr->value].hasUnseenCalls = true; + } + } + for (auto& segment : module->table.segments) { + for (auto name : segment.data) { + infoMap[name].hasUnseenCalls = true; + } + } + // Scan all the functions. + DAEScanner(&infoMap).run(runner, module); + // Combine all the info. + std::unordered_map> allCalls; + std::unordered_set tailCallees; + for (auto& pair : infoMap) { + auto& info = pair.second; + for (auto& pair : info.calls) { + auto name = pair.first; + auto& calls = pair.second; + auto& allCallsToName = allCalls[name]; + allCallsToName.insert(allCallsToName.end(), calls.begin(), calls.end()); + } + for (auto& callee : info.tailCallees) { + tailCallees.insert(callee); + } + for (auto& pair : info.droppedCalls) { + allDroppedCalls[pair.first] = pair.second; + } + } + // We now have a mapping of all call sites for each function. Check which + // are always passed the same constant for a particular argument. + for (auto& pair : allCalls) { + auto name = pair.first; + // We can only optimize if we see all the calls and can modify + // them. + if (infoMap[name].hasUnseenCalls) { + continue; + } + auto& calls = pair.second; + auto* func = module->getFunction(name); + auto numParams = func->getNumParams(); + for (Index i = 0; i < numParams; i++) { + Literal value; + for (auto* call : calls) { + assert(call->target == name); + assert(call->operands.size() == numParams); + auto* operand = call->operands[i]; + if (auto* c = operand->dynCast()) { + if (value.type == Type::none) { + // This is the first value seen. + value = c->value; + } else if (value != c->value) { + // Not identical, give up + value = Literal(Type::none); + break; + } + } else { + // Not a constant, give up + value = Literal(Type::none); + break; + } + } + if (value.type != Type::none) { + // Success! We can just apply the constant in the function, which + // makes the parameter value unused, which lets us remove it later. + Builder builder(*module); + func->body = builder.makeSequence( + builder.makeLocalSet(i, builder.makeConst(value)), func->body); + // Mark it as unused, which we know it now is (no point to + // re-scan just for that). + infoMap[name].unusedParams.insert(i); + } + } + } + // Track which functions we changed, and optimize them later if necessary. + std::unordered_set changed; + // We now know which parameters are unused, and can potentially remove them. + for (auto& pair : allCalls) { + auto name = pair.first; + auto& calls = pair.second; + auto* func = module->getFunction(name); + auto numParams = func->getNumParams(); + if (numParams == 0) { + continue; + } + // Iterate downwards, as we may remove more than one. + Index i = numParams - 1; + while (1) { + if (infoMap[name].unusedParams.has(i)) { + // Great, it's not used. Check if none of the calls has a param with + // side effects, as that would prevent us removing them (flattening + // should have been done earlier). + bool canRemove = + std::none_of(calls.begin(), calls.end(), [&](Call* call) { + auto* operand = call->operands[i]; + return EffectAnalyzer(runner->options, module->features, operand) + .hasSideEffects(); + }); + if (canRemove) { + // Wonderful, nothing stands in our way! Do it. + // TODO: parallelize this? + removeParameter(func, i, calls); + changed.insert(func); + } + } + if (i == 0) { + break; + } + i--; + } + } + // We can also tell which calls have all their return values dropped. Note + // that we can't do this if we changed anything so far, as we may have + // modified allCalls (we can't modify a call site twice in one iteration, + // once to remove a param, once to drop the return value). + if (changed.empty()) { + for (auto& func : module->functions) { + if (func->sig.results == Type::none) { + continue; + } + auto name = func->name; + if (infoMap[name].hasUnseenCalls) { + continue; + } + if (infoMap[name].hasTailCalls) { + continue; + } + if (tailCallees.find(name) != tailCallees.end()) { + continue; + } + auto iter = allCalls.find(name); + if (iter == allCalls.end()) { + continue; + } + auto& calls = iter->second; + bool allDropped = + std::all_of(calls.begin(), calls.end(), [&](Call* call) { + return allDroppedCalls.count(call); + }); + if (!allDropped) { + continue; + } + removeReturnValue(func.get(), calls, module); + // TODO Removing a drop may also open optimization opportunities in the + // callers. + changed.insert(func.get()); + } + } + if (optimize && !changed.empty()) { + OptUtils::optimizeAfterInlining(changed, module, runner); + } + return !changed.empty(); + } + +private: + std::unordered_map allDroppedCalls; + + void removeParameter(Function* func, Index i, std::vector& calls) { + // It's cumbersome to adjust local names - TODO don't clear them? + Builder::clearLocalNames(func); + // Remove the parameter from the function. We must add a new local + // for uses of the parameter, but cannot make it use the same index + // (in general). + std::vector params(func->sig.params.begin(), func->sig.params.end()); + auto type = params[i]; + params.erase(params.begin() + i); + func->sig.params = Type(params); + Index newIndex = Builder::addVar(func, type); + // Update local operations. + struct LocalUpdater : public PostWalker { + Index removedIndex; + Index newIndex; + LocalUpdater(Function* func, Index removedIndex, Index newIndex) + : removedIndex(removedIndex), newIndex(newIndex) { + walk(func->body); + } + void visitLocalGet(LocalGet* curr) { updateIndex(curr->index); } + void visitLocalSet(LocalSet* curr) { updateIndex(curr->index); } + void updateIndex(Index& index) { + if (index == removedIndex) { + index = newIndex; + } else if (index > removedIndex) { + index--; + } + } + } localUpdater(func, i, newIndex); + // Remove the arguments from the calls. + for (auto* call : calls) { + call->operands.erase(call->operands.begin() + i); + } + } + + void + removeReturnValue(Function* func, std::vector& calls, Module* module) { + func->sig.results = Type::none; + Builder builder(*module); + // Remove any return values. + struct ReturnUpdater : public PostWalker { + Module* module; + ReturnUpdater(Function* func, Module* module) : module(module) { + walk(func->body); + } + void visitReturn(Return* curr) { + auto* value = curr->value; + assert(value); + curr->value = nullptr; + Builder builder(*module); + replaceCurrent(builder.makeSequence(builder.makeDrop(value), curr)); + } + } returnUpdater(func, module); + // Remove any value flowing out. + if (func->body->type.isConcrete()) { + func->body = builder.makeDrop(func->body); + } + // Remove the drops on the calls. + for (auto* call : calls) { + auto iter = allDroppedCalls.find(call); + assert(iter != allDroppedCalls.end()); + Expression** location = iter->second; + *location = call; + // Update the call's type. + if (call->type != Type::unreachable) { + call->type = Type::none; + } + } + } +}; + +Pass* createDAEPass() { return new DAE(); } + +Pass* createDAEOptimizingPass() { + auto* ret = new DAE(); + ret->optimize = true; + return ret; +} + +} // namespace wasm diff --git a/binaryen/src/passes/DeadCodeElimination.cpp b/binaryen/src/passes/DeadCodeElimination.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/passes/DeadCodeElimination.cpp @@ -0,0 +1,573 @@ +/* + * Copyright 2016 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// Removes dead, i.e. unreachable, code. +// +// We keep a record of when control flow is reachable. When it isn't, we +// kill (turn into unreachable). We then fold away entire unreachable +// expressions. +// +// When dead code causes an operation to not happen, like a store, a call +// or an add, we replace with a block with a list of what does happen. +// That isn't necessarily smaller, but blocks are friendlier to other +// optimizations: blocks can be merged and eliminated, and they clearly +// have no side effects. +// + +#include +#include +#include +#include +#include +#include +#include + +namespace wasm { + +struct DeadCodeElimination + : public WalkerPass> { + bool isFunctionParallel() override { return true; } + + Pass* create() override { return new DeadCodeElimination; } + + // as we remove code, we must keep the types of other nodes valid + TypeUpdater typeUpdater; + + Expression* replaceCurrent(Expression* expression) { + auto* old = getCurrent(); + if (old == expression) { + return expression; + } + super::replaceCurrent(expression); + // also update the type updater + typeUpdater.noteReplacement(old, expression); + return expression; + } + + // whether the current code is actually reachable + bool reachable; + + void doWalkFunction(Function* func) { + reachable = true; + typeUpdater.walk(func->body); + walk(func->body); + } + + std::set reachableBreaks; + + void addBreak(Name name) { + // we normally have already reduced unreachable code into (unreachable) + // nodes, so we would not get to this place at all anyhow, the breaking + // instruction itself would be removed. However, an exception are things + // like (block (result i32) (call $x) (unreachable)) , which has type i32 + // despite not being exited. + // TODO: optimize such cases + if (reachable) { + reachableBreaks.insert(name); + } + } + + // if a child exists and is unreachable, we can replace ourselves with it + bool isDead(Expression* child) { + return child && child->type == Type::unreachable; + } + + // a similar check, assumes the child exists + bool isUnreachable(Expression* child) { + return child->type == Type::unreachable; + } + + // things that stop control flow + + void visitBreak(Break* curr) { + if (isDead(curr->value)) { + // the condition is evaluated last, so if the value was unreachable, the + // whole thing is + replaceCurrent(curr->value); + return; + } + if (isDead(curr->condition)) { + if (curr->value) { + auto* block = getModule()->allocator.alloc(); + block->list.resize(2); + block->list[0] = drop(curr->value); + block->list[1] = curr->condition; + // if we previously returned a value, then this block + // must have the same type, so it fits in the ast + // properly. it ends in an unreachable + // anyhow, so that is ok. + block->finalize(curr->type); + replaceCurrent(block); + } else { + replaceCurrent(curr->condition); + } + return; + } + addBreak(curr->name); + if (!curr->condition) { + reachable = false; + } + } + + void visitSwitch(Switch* curr) { + if (isDead(curr->value)) { + replaceCurrent(curr->value); + return; + } + if (isUnreachable(curr->condition)) { + if (curr->value) { + auto* block = getModule()->allocator.alloc(); + block->list.resize(2); + block->list[0] = drop(curr->value); + block->list[1] = curr->condition; + block->finalize(curr->type); + replaceCurrent(block); + } else { + replaceCurrent(curr->condition); + } + return; + } + for (auto target : curr->targets) { + addBreak(target); + } + addBreak(curr->default_); + reachable = false; + } + + void visitReturn(Return* curr) { + if (isDead(curr->value)) { + replaceCurrent(curr->value); + return; + } + reachable = false; + } + + void visitUnreachable(Unreachable* curr) { reachable = false; } + + void visitBlock(Block* curr) { + auto& list = curr->list; + // if we are currently unreachable (before we take into account + // breaks to the block) then a child may be unreachable, and we + // can shorten + if (!reachable && list.size() > 1) { + // to do here: nothing to remove after it) + for (Index i = 0; i < list.size() - 1; i++) { + if (list[i]->type == Type::unreachable) { + list.resize(i + 1); + break; + } + } + } + if (curr->name.is()) { + reachable = reachable || reachableBreaks.count(curr->name); + reachableBreaks.erase(curr->name); + } + if (list.size() == 1 && isUnreachable(list[0])) { + replaceCurrent( + BlockUtils::simplifyToContentsWithPossibleTypeChange(curr, this)); + } else { + // the block may have had a type, but can now be unreachable, which allows + // more reduction outside + typeUpdater.maybeUpdateTypeToUnreachable(curr); + } + } + + void visitLoop(Loop* curr) { + if (curr->name.is()) { + reachableBreaks.erase(curr->name); + } + if (isUnreachable(curr->body) && + !BranchUtils::BranchSeeker::has(curr->body, curr->name)) { + replaceCurrent(curr->body); + return; + } + } + + // ifs and trys need special handling: only one of (if body and else body / + // try body and catch body) should be reachable to make the whole of (if / + // try) to be reachable. + + // stack of reachable state, for forking and joining + std::vector ifStack; + std::vector tryStack; + + static void doAfterIfCondition(DeadCodeElimination* self, + Expression** currp) { + self->ifStack.push_back(self->reachable); + } + + static void doAfterIfElseTrue(DeadCodeElimination* self, Expression** currp) { + assert((*currp)->cast()->ifFalse); + bool reachableBefore = self->ifStack.back(); + self->ifStack.pop_back(); + self->ifStack.push_back(self->reachable); + self->reachable = reachableBefore; + } + + void visitIf(If* curr) { + // the ifStack has the branch that joins us, either from before if just an + // if, or the ifTrue if an if-else + reachable = reachable || ifStack.back(); + ifStack.pop_back(); + if (isUnreachable(curr->condition)) { + replaceCurrent(curr->condition); + } + // the if may have had a type, but can now be unreachable, which allows more + // reduction outside + typeUpdater.maybeUpdateTypeToUnreachable(curr); + } + + static void doBeforeTryBody(DeadCodeElimination* self, Expression** currp) { + self->tryStack.push_back(self->reachable); + } + + static void doAfterTryBody(DeadCodeElimination* self, Expression** currp) { + bool reachableBefore = self->tryStack.back(); + self->tryStack.pop_back(); + self->tryStack.push_back(self->reachable); + self->reachable = reachableBefore; + } + + void visitTry(Try* curr) { + // the tryStack has the branch that joins us + reachable = reachable || tryStack.back(); + tryStack.pop_back(); + // the try may have had a type, but can now be unreachable, which allows + // more reduction outside + typeUpdater.maybeUpdateTypeToUnreachable(curr); + } + + void visitThrow(Throw* curr) { reachable = false; } + + void visitRethrow(Rethrow* curr) { reachable = false; } + + void visitBrOnExn(BrOnExn* curr) { + if (isDead(curr->exnref)) { + replaceCurrent(curr->exnref); + return; + } + addBreak(curr->name); + } + + static void scan(DeadCodeElimination* self, Expression** currp) { + auto* curr = *currp; + if (!self->reachable) { +// convert to an unreachable safely +#define DELEGATE(CLASS_TO_VISIT) \ + { \ + auto* parent = self->typeUpdater.parents[curr]; \ + self->typeUpdater.noteRecursiveRemoval(curr); \ + ExpressionManipulator::convert( \ + static_cast(curr)); \ + self->typeUpdater.noteAddition(curr, parent); \ + break; \ + } + switch (curr->_id) { + case Expression::Id::BlockId: + DELEGATE(Block); + case Expression::Id::IfId: + DELEGATE(If); + case Expression::Id::LoopId: + DELEGATE(Loop); + case Expression::Id::BreakId: + DELEGATE(Break); + case Expression::Id::SwitchId: + DELEGATE(Switch); + case Expression::Id::CallId: + DELEGATE(Call); + case Expression::Id::CallIndirectId: + DELEGATE(CallIndirect); + case Expression::Id::LocalGetId: + DELEGATE(LocalGet); + case Expression::Id::LocalSetId: + DELEGATE(LocalSet); + case Expression::Id::GlobalGetId: + DELEGATE(GlobalGet); + case Expression::Id::GlobalSetId: + DELEGATE(GlobalSet); + case Expression::Id::LoadId: + DELEGATE(Load); + case Expression::Id::StoreId: + DELEGATE(Store); + case Expression::Id::ConstId: + DELEGATE(Const); + case Expression::Id::UnaryId: + DELEGATE(Unary); + case Expression::Id::BinaryId: + DELEGATE(Binary); + case Expression::Id::SelectId: + DELEGATE(Select); + case Expression::Id::DropId: + DELEGATE(Drop); + case Expression::Id::ReturnId: + DELEGATE(Return); + case Expression::Id::MemorySizeId: + DELEGATE(MemorySize); + case Expression::Id::MemoryGrowId: + DELEGATE(MemoryGrow); + case Expression::Id::NopId: + DELEGATE(Nop); + case Expression::Id::UnreachableId: + break; + case Expression::Id::AtomicCmpxchgId: + DELEGATE(AtomicCmpxchg); + case Expression::Id::AtomicRMWId: + DELEGATE(AtomicRMW); + case Expression::Id::AtomicWaitId: + DELEGATE(AtomicWait); + case Expression::Id::AtomicNotifyId: + DELEGATE(AtomicNotify); + case Expression::Id::AtomicFenceId: + DELEGATE(AtomicFence); + case Expression::Id::SIMDExtractId: + DELEGATE(SIMDExtract); + case Expression::Id::SIMDReplaceId: + DELEGATE(SIMDReplace); + case Expression::Id::SIMDShuffleId: + DELEGATE(SIMDShuffle); + case Expression::Id::SIMDTernaryId: + DELEGATE(SIMDTernary); + case Expression::Id::SIMDShiftId: + DELEGATE(SIMDShift); + case Expression::Id::SIMDLoadId: + DELEGATE(SIMDLoad); + case Expression::Id::MemoryInitId: + DELEGATE(MemoryInit); + case Expression::Id::DataDropId: + DELEGATE(DataDrop); + case Expression::Id::MemoryCopyId: + DELEGATE(MemoryCopy); + case Expression::Id::MemoryFillId: + DELEGATE(MemoryFill); + case Expression::Id::PopId: + DELEGATE(Pop); + case Expression::Id::RefNullId: + DELEGATE(RefNull); + case Expression::Id::RefIsNullId: + DELEGATE(RefIsNull); + case Expression::Id::RefFuncId: + DELEGATE(RefFunc); + case Expression::Id::RefEqId: + DELEGATE(RefEq); + case Expression::Id::TryId: + DELEGATE(Try); + case Expression::Id::ThrowId: + DELEGATE(Throw); + case Expression::Id::RethrowId: + DELEGATE(Rethrow); + case Expression::Id::BrOnExnId: + DELEGATE(BrOnExn); + case Expression::Id::TupleMakeId: + DELEGATE(TupleMake); + case Expression::Id::TupleExtractId: + DELEGATE(TupleExtract); + case Expression::Id::I31NewId: + DELEGATE(I31New); + case Expression::Id::I31GetId: + DELEGATE(I31Get); + case Expression::Id::RefTestId: + DELEGATE(RefTest); + case Expression::Id::RefCastId: + DELEGATE(RefCast); + case Expression::Id::BrOnCastId: + DELEGATE(BrOnCast); + case Expression::Id::RttCanonId: + DELEGATE(RttCanon); + case Expression::Id::RttSubId: + DELEGATE(RttSub); + case Expression::Id::StructNewId: + DELEGATE(StructNew); + case Expression::Id::StructGetId: + DELEGATE(StructGet); + case Expression::Id::StructSetId: + DELEGATE(StructSet); + case Expression::Id::ArrayNewId: + DELEGATE(ArrayNew); + case Expression::Id::ArrayGetId: + DELEGATE(ArrayGet); + case Expression::Id::ArraySetId: + DELEGATE(ArraySet); + case Expression::Id::ArrayLenId: + DELEGATE(ArrayLen); + case Expression::Id::InvalidId: + WASM_UNREACHABLE("unimp"); + case Expression::Id::NumExpressionIds: + WASM_UNREACHABLE("unimp"); + } +#undef DELEGATE + return; + } + if (curr->is()) { + self->pushTask(DeadCodeElimination::doVisitIf, currp); + if (curr->cast()->ifFalse) { + self->pushTask(DeadCodeElimination::scan, &curr->cast()->ifFalse); + self->pushTask(DeadCodeElimination::doAfterIfElseTrue, currp); + } + self->pushTask(DeadCodeElimination::scan, &curr->cast()->ifTrue); + self->pushTask(DeadCodeElimination::doAfterIfCondition, currp); + self->pushTask(DeadCodeElimination::scan, &curr->cast()->condition); + } else if (curr->is()) { + self->pushTask(DeadCodeElimination::doVisitTry, currp); + self->pushTask(DeadCodeElimination::scan, &curr->cast()->catchBody); + self->pushTask(DeadCodeElimination::doAfterTryBody, currp); + self->pushTask(DeadCodeElimination::scan, &curr->cast()->body); + self->pushTask(DeadCodeElimination::doBeforeTryBody, currp); + } else { + super::scan(self, currp); + } + } + + // other things + + // we don't need to drop unreachable nodes + Expression* drop(Expression* toDrop) { + if (toDrop->type == Type::unreachable) { + return toDrop; + } + return Builder(*getModule()).makeDrop(toDrop); + } + + template Expression* handleCall(T* curr) { + for (Index i = 0; i < curr->operands.size(); i++) { + if (isUnreachable(curr->operands[i])) { + if (i > 0) { + auto* block = getModule()->allocator.alloc(); + Index newSize = i + 1; + block->list.resize(newSize); + Index j = 0; + for (; j < newSize; j++) { + block->list[j] = drop(curr->operands[j]); + } + block->finalize(curr->type); + return replaceCurrent(block); + } else { + return replaceCurrent(curr->operands[i]); + } + } + } + return curr; + } + + void visitCall(Call* curr) { + handleCall(curr); + if (curr->isReturn) { + reachable = false; + } + } + + void visitCallIndirect(CallIndirect* curr) { + if (handleCall(curr) != curr) { + return; + } + if (isUnreachable(curr->target)) { + auto* block = getModule()->allocator.alloc(); + for (auto* operand : curr->operands) { + block->list.push_back(drop(operand)); + } + block->list.push_back(curr->target); + block->finalize(curr->type); + replaceCurrent(block); + } + if (curr->isReturn) { + reachable = false; + } + } + + // Append the reachable operands of the current node to a block, and replace + // it with the block + void blockifyReachableOperands(std::vector&& list, Type type) { + for (size_t i = 0; i < list.size(); ++i) { + auto* elem = list[i]; + if (isUnreachable(elem)) { + auto* replacement = elem; + if (i > 0) { + auto* block = getModule()->allocator.alloc(); + for (size_t j = 0; j < i; ++j) { + block->list.push_back(drop(list[j])); + } + block->list.push_back(list[i]); + block->finalize(type); + replacement = block; + } + replaceCurrent(replacement); + return; + } + } + } + + void visitLocalSet(LocalSet* curr) { + blockifyReachableOperands({curr->value}, curr->type); + } + + void visitGlobalSet(GlobalSet* curr) { + blockifyReachableOperands({curr->value}, curr->type); + } + + void visitLoad(Load* curr) { + blockifyReachableOperands({curr->ptr}, curr->type); + } + + void visitStore(Store* curr) { + blockifyReachableOperands({curr->ptr, curr->value}, curr->type); + } + + void visitAtomicRMW(AtomicRMW* curr) { + blockifyReachableOperands({curr->ptr, curr->value}, curr->type); + } + + void visitAtomicCmpxchg(AtomicCmpxchg* curr) { + blockifyReachableOperands({curr->ptr, curr->expected, curr->replacement}, + curr->type); + } + + void visitUnary(Unary* curr) { + blockifyReachableOperands({curr->value}, curr->type); + } + + void visitBinary(Binary* curr) { + blockifyReachableOperands({curr->left, curr->right}, curr->type); + } + + void visitSelect(Select* curr) { + blockifyReachableOperands({curr->ifTrue, curr->ifFalse, curr->condition}, + curr->type); + } + + void visitDrop(Drop* curr) { + blockifyReachableOperands({curr->value}, curr->type); + } + + void visitMemorySize(MemorySize* curr) {} + + void visitMemoryGrow(MemoryGrow* curr) { + blockifyReachableOperands({curr->delta}, curr->type); + } + + void visitRefIsNull(RefIsNull* curr) { + blockifyReachableOperands({curr->value}, curr->type); + } + + void visitRefEq(RefEq* curr) { + blockifyReachableOperands({curr->left, curr->right}, curr->type); + } + + void visitFunction(Function* curr) { assert(reachableBreaks.size() == 0); } +}; + +Pass* createDeadCodeEliminationPass() { return new DeadCodeElimination(); } + +} // namespace wasm diff --git a/binaryen/src/passes/Directize.cpp b/binaryen/src/passes/Directize.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/passes/Directize.cpp @@ -0,0 +1,120 @@ +/* + * Copyright 2019 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// Turn indirect calls into direct calls. This is possible if we know +// the table cannot change, and if we see a constant argument for the +// indirect call's index. +// + +#include + +#include "asm_v_wasm.h" +#include "ir/table-utils.h" +#include "ir/utils.h" +#include "pass.h" +#include "wasm-builder.h" +#include "wasm-traversal.h" +#include "wasm.h" + +namespace wasm { + +namespace { + +struct FunctionDirectizer : public WalkerPass> { + bool isFunctionParallel() override { return true; } + + Pass* create() override { return new FunctionDirectizer(flatTable); } + + FunctionDirectizer(TableUtils::FlatTable* flatTable) : flatTable(flatTable) {} + + void visitCallIndirect(CallIndirect* curr) { + if (auto* c = curr->target->dynCast()) { + Index index = c->value.geti32(); + // If the index is invalid, or the type is wrong, we can + // emit an unreachable here, since in Binaryen it is ok to + // reorder/replace traps when optimizing (but never to + // remove them, at least not by default). + if (index >= flatTable->names.size()) { + replaceWithUnreachable(curr); + return; + } + auto name = flatTable->names[index]; + if (!name.is()) { + replaceWithUnreachable(curr); + return; + } + auto* func = getModule()->getFunction(name); + if (curr->sig != func->sig) { + replaceWithUnreachable(curr); + return; + } + // Everything looks good! + replaceCurrent( + Builder(*getModule()) + .makeCall(name, curr->operands, curr->type, curr->isReturn)); + } + } + + void doWalkFunction(Function* func) { + WalkerPass>::doWalkFunction(func); + if (changedTypes) { + ReFinalize().walkFunctionInModule(func, getModule()); + } + } + +private: + TableUtils::FlatTable* flatTable; + bool changedTypes = false; + + void replaceWithUnreachable(CallIndirect* call) { + Builder builder(*getModule()); + for (auto*& operand : call->operands) { + operand = builder.makeDrop(operand); + } + replaceCurrent(builder.makeSequence(builder.makeBlock(call->operands), + builder.makeUnreachable())); + changedTypes = true; + } +}; + +struct Directize : public Pass { + void run(PassRunner* runner, Module* module) override { + if (!module->table.exists) { + return; + } + if (module->table.imported()) { + return; + } + for (auto& ex : module->exports) { + if (ex->kind == ExternalKind::Table) { + return; + } + } + TableUtils::FlatTable flatTable(module->table); + if (!flatTable.valid) { + return; + } + // The table exists and is constant, so this is possible. + FunctionDirectizer(&flatTable).run(runner, module); + } +}; + +} // anonymous namespace + +Pass* createDirectizePass() { return new Directize(); } + +} // namespace wasm diff --git a/binaryen/src/passes/DuplicateFunctionElimination.cpp b/binaryen/src/passes/DuplicateFunctionElimination.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/passes/DuplicateFunctionElimination.cpp @@ -0,0 +1,106 @@ +/* + * Copyright 2016 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// Removes duplicate functions. That can happen due to C++ templates, +// and also due to types being different at the source level, but +// identical when finally lowered into concrete wasm code. +// + +#include "ir/function-utils.h" +#include "ir/hashed.h" +#include "ir/module-utils.h" +#include "ir/utils.h" +#include "opt-utils.h" +#include "pass.h" +#include "wasm.h" + +namespace wasm { + +struct DuplicateFunctionElimination : public Pass { + void run(PassRunner* runner, Module* module) override { + // Multiple iterations may be necessary: A and B may be identical only after + // we see the functions C1 and C2 that they call are in fact identical. + // Rarely, such "chains" can be very long, so we limit how many we do. + auto& options = runner->options; + Index limit; + if (options.optimizeLevel >= 3 || options.shrinkLevel >= 1) { + limit = module->functions.size(); // no limit + } else if (options.optimizeLevel >= 2) { + // 10 passes usually does most of the work, as this is typically + // logarithmic + limit = 10; + } else { + limit = 1; + } + while (limit > 0) { + limit--; + // Hash all the functions + auto hashes = FunctionHasher::createMap(module); + FunctionHasher(&hashes).run(runner, module); + // Find hash-equal groups + std::map> hashGroups; + ModuleUtils::iterDefinedFunctions(*module, [&](Function* func) { + hashGroups[hashes[func]].push_back(func); + }); + // Find actually equal functions and prepare to replace them + std::map replacements; + std::set duplicates; + for (auto& pair : hashGroups) { + auto& group = pair.second; + Index size = group.size(); + if (size == 1) { + continue; + } + // The groups should be fairly small, and even if a group is large we + // should have almost all of them identical, so we should not hit actual + // O(N^2) here unless the hash is quite poor. + for (Index i = 0; i < size - 1; i++) { + auto* first = group[i]; + if (duplicates.count(first->name)) { + continue; + } + for (Index j = i + 1; j < size; j++) { + auto* second = group[j]; + if (duplicates.count(second->name)) { + continue; + } + if (FunctionUtils::equal(first, second)) { + // great, we can replace the second with the first! + replacements[second->name] = first->name; + duplicates.insert(second->name); + } + } + } + } + // perform replacements + if (replacements.size() > 0) { + // remove the duplicates + module->removeFunctions( + [&](Function* func) { return duplicates.count(func->name) > 0; }); + OptUtils::replaceFunctions(runner, *module, replacements); + } else { + break; + } + } + } +}; + +Pass* createDuplicateFunctionEliminationPass() { + return new DuplicateFunctionElimination(); +} + +} // namespace wasm diff --git a/binaryen/src/passes/DuplicateImportElimination.cpp b/binaryen/src/passes/DuplicateImportElimination.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/passes/DuplicateImportElimination.cpp @@ -0,0 +1,67 @@ +/* + * Copyright 2019 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// Removes duplicate imports. +// +// TODO: non-function imports too +// + +#include "asm_v_wasm.h" +#include "ir/import-utils.h" +#include "opt-utils.h" +#include "pass.h" +#include "wasm.h" + +namespace wasm { + +struct DuplicateImportElimination : public Pass { + void run(PassRunner* runner, Module* module) override { + ImportInfo imports(*module); + std::map replacements; + std::map, Name> seen; + std::vector toRemove; + for (auto* func : imports.importedFunctions) { + auto pair = std::make_pair(func->module, func->base); + auto iter = seen.find(pair); + if (iter != seen.end()) { + auto previousName = iter->second; + auto previousFunc = module->getFunction(previousName); + // It is ok to import the same thing with multiple types; we can only + // merge if the types match, of course. + if (previousFunc->sig == func->sig) { + replacements[func->name] = previousName; + toRemove.push_back(func->name); + continue; + } + } + seen[pair] = func->name; + } + if (!replacements.empty()) { + module->updateMaps(); + OptUtils::replaceFunctions(runner, *module, replacements); + for (auto name : toRemove) { + module->removeFunction(name); + } + } + } +}; + +Pass* createDuplicateImportEliminationPass() { + return new DuplicateImportElimination(); +} + +} // namespace wasm diff --git a/binaryen/src/passes/EmscriptenPIC.cpp b/binaryen/src/passes/EmscriptenPIC.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/passes/EmscriptenPIC.cpp @@ -0,0 +1,221 @@ +/* + * Copyright 2020 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// Convert LLVM PIC ABI to emscripten ABI +// +// When generating -fPIC code llvm will generate imports call GOT.mem and +// GOT.func in order to access the addresses of external global data and +// functions. +// +// However emscripten uses a different ABI where function and data addresses +// are available at runtime via special `g$foo` and `fp$bar` function calls. +// +// Here we internalize all such wasm globals and generte code that sets their +// value based on the result of call `g$foo` and `fp$bar` functions at runtime. +// +// A function called `__assign_got_enties` is generated by this pass that +// performs all the assignments. +// + +#include "abi/js.h" +#include "asm_v_wasm.h" +#include "ir/import-utils.h" +#include "ir/table-utils.h" +#include "pass.h" +#include "shared-constants.h" +#include "support/debug.h" + +#define DEBUG_TYPE "emscripten-pic" + +namespace wasm { + +static Global* ensureGlobalImport(Module* module, Name name, Type type) { + // See if its already imported. + // FIXME: O(N) + ImportInfo info(*module); + if (auto* g = info.getImportedGlobal(ENV, name)) { + return g; + } + // Failing that create a new import. + auto import = new Global; + import->name = name; + import->module = ENV; + import->base = name; + import->type = type; + module->addGlobal(import); + return import; +} + +static Function* +ensureFunctionImport(Module* module, Name name, Signature sig) { + // See if its already imported. + // FIXME: O(N) + ImportInfo info(*module); + if (auto* f = info.getImportedFunction(ENV, name)) { + return f; + } + // Failing that create a new import. + auto import = new Function; + import->name = name; + import->module = ENV; + import->base = name; + import->sig = sig; + module->addFunction(import); + return import; +} + +struct EmscriptenPIC : public WalkerPass> { + + EmscriptenPIC(bool sideModule) : sideModule(sideModule) {} + + void visitGlobal(Global* curr) { + if (!curr->imported()) { + return; + } + if (curr->module == "GOT.func") { + gotFuncEntries.push_back(curr); + } else if (curr->module == "GOT.mem") { + gotMemEntries.push_back(curr); + } else { + return; + } + // Make this an internal, non-imported, global. + curr->module.clear(); + curr->init = Builder(*getModule()).makeConst(int32_t(0)); + } + + void visitModule(Module* module) { + BYN_TRACE("generateAssignGOTEntriesFunction\n"); + if (!gotFuncEntries.size() && !gotMemEntries.size()) { + return; + } + + Builder builder(*getModule()); + Function* assignFunc = builder.makeFunction( + ASSIGN_GOT_ENTRIES, std::vector{}, Type::none, {}); + Block* block = builder.makeBlock(); + assignFunc->body = block; + + bool hasSingleMemorySegment = + module->memory.exists && module->memory.segments.size() == 1; + + for (Global* g : gotMemEntries) { + // If this global is defined in this module, we export its address + // relative to the relocatable memory. If we are in a main module, we can + // just use that location (since if other modules have this symbol too, we + // will "win" as we are loaded first). Otherwise, import a g$ getter. Note + // that this depends on memory having a single segment, so we know the + // offset, and that the export is a global. + auto base = g->base; + if (hasSingleMemorySegment && !sideModule) { + if (auto* ex = module->getExportOrNull(base)) { + if (ex->kind == ExternalKind::Global) { + // The base relative to which we are computed is the offset of the + // singleton segment. + auto* relativeBase = ExpressionManipulator::copy( + module->memory.segments[0].offset, *module); + + auto* offset = builder.makeGlobalGet( + ex->value, module->getGlobal(ex->value)->type); + auto* add = builder.makeBinary(AddInt32, relativeBase, offset); + GlobalSet* globalSet = builder.makeGlobalSet(g->name, add); + block->list.push_back(globalSet); + continue; + } + } + } + Name getter(std::string("g$") + base.c_str()); + ensureFunctionImport(module, getter, Signature(Type::none, Type::i32)); + Expression* call = builder.makeCall(getter, {}, Type::i32); + GlobalSet* globalSet = builder.makeGlobalSet(g->name, call); + block->list.push_back(globalSet); + } + + ImportInfo importInfo(*module); + + // We may have to add things to the table. + Global* tableBase = nullptr; + + for (Global* g : gotFuncEntries) { + // The function has to exist either as export or an import. + // Note that we don't search for the function by name since its internal + // name may be different. + auto* ex = module->getExportOrNull(g->base); + // If this is exported then it must be one of the functions implemented + // here, and if this is a main module, then we can simply place the + // function in the table: the loader will see it there and resolve all + // other uses to this one. + if (ex && !sideModule) { + assert(ex->kind == ExternalKind::Function); + auto* f = module->getFunction(ex->value); + if (f->imported()) { + Fatal() << "GOT.func entry is both imported and exported: " + << g->base; + } + // The base relative to which we are computed is the offset of the + // singleton segment, which we must ensure exists + if (!tableBase) { + tableBase = ensureGlobalImport(module, TABLE_BASE, Type::i32); + } + if (!module->table.exists) { + module->table.exists = true; + } + if (module->table.segments.empty()) { + module->table.segments.resize(1); + module->table.segments[0].offset = + builder.makeGlobalGet(tableBase->name, Type::i32); + } + auto tableIndex = + TableUtils::getOrAppend(module->table, f->name, *module); + auto* c = LiteralUtils::makeFromInt32(tableIndex, Type::i32, *module); + auto* getBase = builder.makeGlobalGet(tableBase->name, Type::i32); + auto* add = builder.makeBinary(AddInt32, getBase, c); + auto* globalSet = builder.makeGlobalSet(g->name, add); + block->list.push_back(globalSet); + continue; + } + // This is imported or in a side module. Create an fp$ import to get the + // function table index from the dynamic loader. + auto* f = importInfo.getImportedFunction(ENV, g->base); + if (!f) { + if (!ex) { + Fatal() << "GOT.func entry with no import/export: " << g->base; + } + f = module->getFunction(ex->value); + } + Name getter( + (std::string("fp$") + g->base.c_str() + std::string("$") + getSig(f)) + .c_str()); + ensureFunctionImport(module, getter, Signature(Type::none, Type::i32)); + auto* call = builder.makeCall(getter, {}, Type::i32); + auto* globalSet = builder.makeGlobalSet(g->name, call); + block->list.push_back(globalSet); + } + + module->addFunction(assignFunc); + } + + std::vector gotFuncEntries; + std::vector gotMemEntries; + bool sideModule; +}; + +Pass* createEmscriptenPICPass() { return new EmscriptenPIC(true); } + +Pass* createEmscriptenPICMainModulePass() { return new EmscriptenPIC(false); } + +} // namespace wasm diff --git a/binaryen/src/passes/ExtractFunction.cpp b/binaryen/src/passes/ExtractFunction.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/passes/ExtractFunction.cpp @@ -0,0 +1,66 @@ +/* + * Copyright 2016 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// Removes code from all functions but one, leaving a valid module +// with (mostly) just the code you want to debug (function-parallel, +// non-lto) passes on. + +#include "pass.h" +#include "wasm.h" + +namespace wasm { + +struct ExtractFunction : public Pass { + void run(PassRunner* runner, Module* module) override { + Name name = runner->options.getArgument( + "extract", + "ExtractFunction usage: wasm-opt --pass-arg=extract@FUNCTION_NAME"); + std::cerr << "extracting " << name << "\n"; + bool found = false; + for (auto& func : module->functions) { + if (func->name != name) { + // Turn it into an import. + func->module = "env"; + func->base = func->name; + func->vars.clear(); + func->body = nullptr; + } else { + found = true; + } + } + if (!found) { + Fatal() << "could not find the function to extract\n"; + } + // clear data + module->memory.segments.clear(); + module->table.segments.clear(); + // leave just an export for the thing we want + if (!module->getExportOrNull(name)) { + module->exports.clear(); + auto* export_ = new Export; + export_->name = name; + export_->value = name; + export_->kind = ExternalKind::Function; + module->addExport(export_); + } + } +}; + +// declare pass + +Pass* createExtractFunctionPass() { return new ExtractFunction(); } + +} // namespace wasm diff --git a/binaryen/src/passes/Flatten.cpp b/binaryen/src/passes/Flatten.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/passes/Flatten.cpp @@ -0,0 +1,359 @@ +/* + * Copyright 2017 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// Flattens code into "Flat IR" form. See ir/flat.h. +// + +#include +#include +#include +#include +#include +#include +#include +#include + +namespace wasm { + +// We use the following algorithm: we maintain a list of "preludes", code +// that runs right before an expression. When we visit an expression we +// must handle it and its preludes. If the expression has side effects, +// we reduce it to a local.get and add a prelude for that. We then handle +// the preludes, by moving them to the parent or handling them directly. +// we can move them to the parent if the parent is not a control flow +// structure. Otherwise, if the parent is a control flow structure, it +// will incorporate the preludes of its children accordingly. +// As a result, when we reach a node, we know its children have no +// side effects (they have been moved to a prelude), or we are a +// control flow structure (which allows children with side effects, +// e.g. a return as a block element). +// Once exception is that we allow an (unreachable) node, which is used +// when we move something unreachable to another place, and need a +// placeholder. We will never reach that (unreachable) anyhow +struct Flatten + : public WalkerPass< + ExpressionStackWalker>> { + bool isFunctionParallel() override { return true; } + + Pass* create() override { return new Flatten; } + + // For each expression, a bunch of expressions that should execute right + // before it + std::unordered_map> preludes; + + // Break values are sent through a temp local + std::unordered_map breakTemps; + + void visitExpression(Expression* curr) { + std::vector ourPreludes; + Builder builder(*getModule()); + + // Nothing to do for constants and nop. + if (Properties::isConstantExpression(curr) || curr->is()) { + return; + } + + if (curr->is() || curr->is() || curr->is() || + curr->is()) { + Fatal() << "Flatten does not support EH instructions yet"; + } + + if (Properties::isControlFlowStructure(curr)) { + // handle control flow explicitly. our children do not have control flow, + // but they do have preludes which we need to set up in the right place + + // no one should have given us preludes, they are on the children + assert(preludes.find(curr) == preludes.end()); + + if (auto* block = curr->dynCast()) { + // make a new list, where each item's preludes are added before it + ExpressionList newList(getModule()->allocator); + for (auto* item : block->list) { + auto iter = preludes.find(item); + if (iter != preludes.end()) { + auto& itemPreludes = iter->second; + for (auto* prelude : itemPreludes) { + newList.push_back(prelude); + } + itemPreludes.clear(); + } + newList.push_back(item); + } + block->list.swap(newList); + // remove a block return value + auto type = block->type; + if (type.isConcrete()) { + // if there is a temp index for breaking to the block, use that + Index temp; + auto iter = breakTemps.find(block->name); + if (iter != breakTemps.end()) { + temp = iter->second; + } else { + temp = builder.addVar(getFunction(), type); + } + auto*& last = block->list.back(); + if (last->type.isConcrete()) { + last = builder.makeLocalSet(temp, last); + } + block->finalize(Type::none); + // and we leave just a get of the value + auto* rep = builder.makeLocalGet(temp, type); + replaceCurrent(rep); + // the whole block is now a prelude + ourPreludes.push_back(block); + } + // the block now has no return value, and may have become unreachable + block->finalize(Type::none); + + } else if (auto* iff = curr->dynCast()) { + // condition preludes go before the entire if + auto* rep = getPreludesWithExpression(iff->condition, iff); + // arm preludes go in the arms. we must also remove an if value + auto* originalIfTrue = iff->ifTrue; + auto* originalIfFalse = iff->ifFalse; + auto type = iff->type; + Expression* prelude = nullptr; + if (type.isConcrete()) { + Index temp = builder.addVar(getFunction(), type); + if (iff->ifTrue->type.isConcrete()) { + iff->ifTrue = builder.makeLocalSet(temp, iff->ifTrue); + } + if (iff->ifFalse && iff->ifFalse->type.isConcrete()) { + iff->ifFalse = builder.makeLocalSet(temp, iff->ifFalse); + } + // the whole if (+any preludes from the condition) is now a prelude + prelude = rep; + // and we leave just a get of the value + rep = builder.makeLocalGet(temp, type); + } + iff->ifTrue = getPreludesWithExpression(originalIfTrue, iff->ifTrue); + if (iff->ifFalse) { + iff->ifFalse = + getPreludesWithExpression(originalIfFalse, iff->ifFalse); + } + iff->finalize(); + if (prelude) { + ReFinalizeNode().visit(prelude); + ourPreludes.push_back(prelude); + } + replaceCurrent(rep); + + } else if (auto* loop = curr->dynCast()) { + // remove a loop value + Expression* rep = loop; + auto* originalBody = loop->body; + auto type = loop->type; + if (type.isConcrete()) { + Index temp = builder.addVar(getFunction(), type); + loop->body = builder.makeLocalSet(temp, loop->body); + // and we leave just a get of the value + rep = builder.makeLocalGet(temp, type); + // the whole if is now a prelude + ourPreludes.push_back(loop); + loop->type = Type::none; + } + loop->body = getPreludesWithExpression(originalBody, loop->body); + loop->finalize(); + replaceCurrent(rep); + + } else { + WASM_UNREACHABLE("unexpected expr type"); + } + + } else { + // for anything else, there may be existing preludes + auto iter = preludes.find(curr); + if (iter != preludes.end()) { + ourPreludes.swap(iter->second); + } + + // special handling + if (auto* set = curr->dynCast()) { + if (set->isTee()) { + // we disallow local.tee + if (set->value->type == Type::unreachable) { + replaceCurrent(set->value); // trivial, no set happens + } else { + // use a set in a prelude + a get + set->makeSet(); + ourPreludes.push_back(set); + Type localType = getFunction()->getLocalType(set->index); + replaceCurrent(builder.makeLocalGet(set->index, localType)); + } + } + + } else if (auto* br = curr->dynCast()) { + if (br->value) { + auto type = br->value->type; + if (type.isConcrete()) { + // we are sending a value. use a local instead + Type blockType = findBreakTarget(br->name)->type; + Index temp = getTempForBreakTarget(br->name, blockType); + ourPreludes.push_back(builder.makeLocalSet(temp, br->value)); + + // br_if leaves a value on the stack if not taken, which later can + // be the last element of the enclosing innermost block and flow + // out. The local we created using 'getTempForBreakTarget' returns + // the return type of the block this branch is targetting, which may + // not be the same with the innermost block's return type. For + // example, + // (block $any (result anyref) + // (block (result funcref) + // (local.tee $0 + // (br_if $any + // (ref.null func) + // (i32.const 0) + // ) + // ) + // ) + // ) + // In this case we need two locals to store (ref.null); one with + // funcref type that's for the target block ($label0) and one more + // with anyref type in case for flowing out. Here we create the + // second 'flowing out' local in case two block's types are + // different. + if (type != blockType) { + temp = builder.addVar(getFunction(), type); + ourPreludes.push_back(builder.makeLocalSet( + temp, ExpressionManipulator::copy(br->value, *getModule()))); + } + + if (br->condition) { + // the value must also flow out + ourPreludes.push_back(br); + if (br->type.isConcrete()) { + replaceCurrent(builder.makeLocalGet(temp, type)); + } else { + assert(br->type == Type::unreachable); + replaceCurrent(builder.makeUnreachable()); + } + } + br->value = nullptr; + br->finalize(); + } else { + assert(type == Type::unreachable); + // we don't need the br at all + replaceCurrent(br->value); + } + } + + } else if (auto* sw = curr->dynCast()) { + if (sw->value) { + auto type = sw->value->type; + if (type.isConcrete()) { + // we are sending a value. use a local instead + Index temp = builder.addVar(getFunction(), type); + ourPreludes.push_back(builder.makeLocalSet(temp, sw->value)); + // we don't know which break target will be hit - assign to them all + auto names = BranchUtils::getUniqueTargets(sw); + for (auto name : names) { + ourPreludes.push_back( + builder.makeLocalSet(getTempForBreakTarget(name, type), + builder.makeLocalGet(temp, type))); + } + sw->value = nullptr; + sw->finalize(); + } else { + assert(type == Type::unreachable); + // we don't need the br at all + replaceCurrent(sw->value); + } + } + } + } + // TODO Handle br_on_exn + + // continue for general handling of everything, control flow or otherwise + curr = getCurrent(); // we may have replaced it + // we have changed children + ReFinalizeNode().visit(curr); + if (curr->type == Type::unreachable) { + ourPreludes.push_back(curr); + replaceCurrent(builder.makeUnreachable()); + } else if (curr->type.isConcrete()) { + // use a local + auto type = curr->type; + Index temp = builder.addVar(getFunction(), type); + ourPreludes.push_back(builder.makeLocalSet(temp, curr)); + replaceCurrent(builder.makeLocalGet(temp, type)); + } + + // next, finish up: migrate our preludes if we can + if (!ourPreludes.empty()) { + auto* parent = getParent(); + if (parent && !Properties::isControlFlowStructure(parent)) { + auto& parentPreludes = preludes[parent]; + for (auto* prelude : ourPreludes) { + parentPreludes.push_back(prelude); + } + } else { + // keep our preludes, parent will handle them + preludes[getCurrent()].swap(ourPreludes); + } + } + } + + void visitFunction(Function* curr) { + auto* originalBody = curr->body; + // if the body is a block with a result, turn that into a return + if (curr->body->type.isConcrete()) { + curr->body = Builder(*getModule()).makeReturn(curr->body); + } + // the body may have preludes + curr->body = getPreludesWithExpression(originalBody, curr->body); + } + +private: + // gets an expression, either by itself, or in a block with its + // preludes (which we use up) before it + Expression* getPreludesWithExpression(Expression* curr) { + return getPreludesWithExpression(curr, curr); + } + + // gets an expression, either by itself, or in a block with some + // preludes (which we use up) for another expression before it + Expression* getPreludesWithExpression(Expression* preluder, + Expression* after) { + auto iter = preludes.find(preluder); + if (iter == preludes.end()) { + return after; + } + // we have preludes + auto& thePreludes = iter->second; + auto* ret = Builder(*getModule()).makeBlock(thePreludes); + thePreludes.clear(); + ret->list.push_back(after); + ret->finalize(); + return ret; + } + + // get the temp local to be used for breaks to that target. allocates + // one if there isn't one yet + Index getTempForBreakTarget(Name name, Type type) { + auto iter = breakTemps.find(name); + if (iter != breakTemps.end()) { + return iter->second; + } else { + return breakTemps[name] = + Builder(*getModule()).addVar(getFunction(), type); + } + } +}; + +Pass* createFlattenPass() { return new Flatten(); } + +} // namespace wasm diff --git a/binaryen/src/passes/FuncCastEmulation.cpp b/binaryen/src/passes/FuncCastEmulation.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/passes/FuncCastEmulation.cpp @@ -0,0 +1,225 @@ +/* + * Copyright 2017 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// Instruments all indirect calls so that they work even if a function +// pointer was cast incorrectly. For example, if you cast an int (int, float) +// to an int (int, float, int) and call it natively, on most archs it will +// happen to work, ignoring the extra param, whereas in wasm it will trap. +// When porting code that relies on such casts working (like e.g. Python), +// this pass may be useful. It sets a new "ABI" for indirect calls, in which +// they all return an i64 and they have a fixed number of i64 params, and +// the pass converts everything to go through that. +// +// This should work even with dynamic linking, however, the number of +// params must be identical, i.e., the "ABI" must match. +// + +#include +#include +#include +#include +#include + +namespace wasm { + +// This should be enough for everybody. (As described above, we need this +// to match when dynamically linking, and also dynamic linking is why we +// can't just detect this automatically in the module we see.) +static const int NUM_PARAMS = 16; + +// Converts a value to the ABI type of i64. +static Expression* toABI(Expression* value, Module* module) { + Builder builder(*module); + switch (value->type.getBasic()) { + case Type::i32: { + value = builder.makeUnary(ExtendUInt32, value); + break; + } + case Type::i64: { + // already good + break; + } + case Type::f32: { + value = builder.makeUnary(ExtendUInt32, + builder.makeUnary(ReinterpretFloat32, value)); + break; + } + case Type::f64: { + value = builder.makeUnary(ReinterpretFloat64, value); + break; + } + case Type::v128: { + WASM_UNREACHABLE("v128 not implemented yet"); + } + case Type::funcref: + case Type::externref: + case Type::exnref: + case Type::anyref: + case Type::eqref: + case Type::i31ref: { + WASM_UNREACHABLE("reference types cannot be converted to i64"); + } + case Type::none: { + // the value is none, but we need a value here + value = + builder.makeSequence(value, LiteralUtils::makeZero(Type::i64, *module)); + break; + } + case Type::unreachable: { + // can leave it, the call isn't taken anyhow + break; + } + } + return value; +} + +// Converts a value from the ABI type of i64 to the expected type +static Expression* fromABI(Expression* value, Type type, Module* module) { + Builder builder(*module); + switch (type.getBasic()) { + case Type::i32: { + value = builder.makeUnary(WrapInt64, value); + break; + } + case Type::i64: { + // already good + break; + } + case Type::f32: { + value = builder.makeUnary(ReinterpretInt32, + builder.makeUnary(WrapInt64, value)); + break; + } + case Type::f64: { + value = builder.makeUnary(ReinterpretInt64, value); + break; + } + case Type::v128: { + WASM_UNREACHABLE("v128 not implemented yet"); + } + case Type::funcref: + case Type::externref: + case Type::exnref: + case Type::anyref: + case Type::eqref: + case Type::i31ref: { + WASM_UNREACHABLE("reference types cannot be converted from i64"); + } + case Type::none: { + value = builder.makeDrop(value); + } + case Type::unreachable: { + // can leave it, the call isn't taken anyhow + break; + } + } + return value; +} + +struct ParallelFuncCastEmulation + : public WalkerPass> { + bool isFunctionParallel() override { return true; } + + Pass* create() override { return new ParallelFuncCastEmulation(ABIType); } + + ParallelFuncCastEmulation(Signature ABIType) : ABIType(ABIType) {} + + void visitCallIndirect(CallIndirect* curr) { + if (curr->operands.size() > NUM_PARAMS) { + Fatal() << "FuncCastEmulation::NUM_PARAMS needs to be at least " + << curr->operands.size(); + } + for (Expression*& operand : curr->operands) { + operand = toABI(operand, getModule()); + } + // Add extra operands as needed. + while (curr->operands.size() < NUM_PARAMS) { + curr->operands.push_back(LiteralUtils::makeZero(Type::i64, *getModule())); + } + // Set the new types + curr->sig = ABIType; + auto oldType = curr->type; + curr->type = Type::i64; + curr->finalize(); // may be unreachable + // Fix up return value + replaceCurrent(fromABI(curr, oldType, getModule())); + } + +private: + // The signature of a call with the right params and return + Signature ABIType; +}; + +struct FuncCastEmulation : public Pass { + void run(PassRunner* runner, Module* module) override { + // we just need the one ABI function type for all indirect calls + Signature ABIType(Type(std::vector(NUM_PARAMS, Type::i64)), + Type::i64); + // Add a thunk for each function in the table, and do the call through it. + std::unordered_map funcThunks; + for (auto& segment : module->table.segments) { + for (auto& name : segment.data) { + auto iter = funcThunks.find(name); + if (iter == funcThunks.end()) { + auto thunk = makeThunk(name, module); + funcThunks[name] = thunk; + name = thunk; + } else { + name = iter->second; + } + } + } + // update call_indirects + ParallelFuncCastEmulation(ABIType).run(runner, module); + } + +private: + // Creates a thunk for a function, casting args and return value as needed. + Name makeThunk(Name name, Module* module) { + Name thunk = std::string("byn$fpcast-emu$") + name.str; + if (module->getFunctionOrNull(thunk)) { + Fatal() << "FuncCastEmulation::makeThunk seems a thunk name already in " + "use. Was the pass already run on this code?"; + } + // The item in the table may be a function or a function import. + auto* func = module->getFunction(name); + Type type = func->sig.results; + Builder builder(*module); + std::vector callOperands; + Index i = 0; + for (const auto& param : func->sig.params) { + callOperands.push_back( + fromABI(builder.makeLocalGet(i++, Type::i64), param, module)); + } + auto* call = builder.makeCall(name, callOperands, type); + std::vector thunkParams; + for (Index i = 0; i < NUM_PARAMS; i++) { + thunkParams.push_back(Type::i64); + } + auto* thunkFunc = + builder.makeFunction(thunk, + Signature(Type(thunkParams), Type::i64), + {}, // no vars + toABI(call, module)); + module->addFunction(thunkFunc); + return thunk; + } +}; + +Pass* createFuncCastEmulationPass() { return new FuncCastEmulation(); } + +} // namespace wasm diff --git a/binaryen/src/passes/GenerateDynCalls.cpp b/binaryen/src/passes/GenerateDynCalls.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/passes/GenerateDynCalls.cpp @@ -0,0 +1,140 @@ +/* + * Copyright 2020 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// Create `dynCall` helper functions used by emscripten. These allow JavaScript +// to call back into WebAssembly given a function pointer (table index). These +// are used primarily to implement the `invoke` functions which in turn are used +// to implment exceptions handling and setjmp/longjmp. Creates one for each +// signature in the indirect function table. +// + +#include "abi/js.h" +#include "asm_v_wasm.h" +#include "ir/import-utils.h" +#include "pass.h" +#include "support/debug.h" +#include "wasm-builder.h" + +#define DEBUG_TYPE "generate-dyncalls" + +namespace wasm { + +struct GenerateDynCalls : public WalkerPass> { + GenerateDynCalls(bool onlyI64) : onlyI64(onlyI64) {} + + void doWalkModule(Module* wasm) { + PostWalker::doWalkModule(wasm); + for (auto& sig : invokeSigs) { + generateDynCallThunk(sig); + } + } + + void visitTable(Table* table) { + // Generate dynCalls for functions in the table + if (table->segments.size() > 0) { + std::vector tableSegmentData; + for (const auto& indirectFunc : table->segments[0].data) { + generateDynCallThunk(getModule()->getFunction(indirectFunc)->sig); + } + } + } + + void visitFunction(Function* func) { + // Generate dynCalls for invokes + if (func->imported() && func->module == ENV && + func->base.startsWith("invoke_")) { + Signature sig = func->sig; + // The first parameter is a pointer to the original function that's called + // by the invoke, so skip it + std::vector newParams(sig.params.begin() + 1, sig.params.end()); + invokeSigs.insert(Signature(Type(newParams), sig.results)); + } + } + + void generateDynCallThunk(Signature sig); + + bool onlyI64; + // The set of all invokes' signatures + std::set invokeSigs; +}; + +static bool hasI64(Signature sig) { + // We only generate dynCall functions for signatures that contain i64. This is + // because any other function can be called directly from JavaScript using the + // wasm table. + for (auto t : sig.results) { + if (t.getID() == Type::i64) { + return true; + } + } + for (auto t : sig.params) { + if (t.getID() == Type::i64) { + return true; + } + } + return false; +} + +static void exportFunction(Module& wasm, Name name, bool must_export) { + if (!wasm.getFunctionOrNull(name)) { + assert(!must_export); + return; + } + if (wasm.getExportOrNull(name)) { + return; // Already exported + } + auto exp = new Export; + exp->name = exp->value = name; + exp->kind = ExternalKind::Function; + wasm.addExport(exp); +} + +void GenerateDynCalls::generateDynCallThunk(Signature sig) { + if (onlyI64 && !hasI64(sig)) { + return; + } + + Module* wasm = getModule(); + Builder builder(*wasm); + Name name = std::string("dynCall_") + getSig(sig.results, sig.params); + if (wasm->getFunctionOrNull(name) || wasm->getExportOrNull(name)) { + return; // module already contains this dyncall + } + std::vector params; + params.emplace_back("fptr", Type::i32); // function pointer param + int p = 0; + for (const auto& param : sig.params) { + params.emplace_back(std::to_string(p++), param); + } + Function* f = builder.makeFunction(name, std::move(params), sig.results, {}); + Expression* fptr = builder.makeLocalGet(0, Type::i32); + std::vector args; + Index i = 0; + for (const auto& param : sig.params) { + args.push_back(builder.makeLocalGet(++i, param)); + } + Expression* call = builder.makeCallIndirect(fptr, args, sig); + f->body = call; + + wasm->addFunction(f); + exportFunction(*wasm, f->name, true); +} + +Pass* createGenerateDynCallsPass() { return new GenerateDynCalls(false); } +Pass* createGenerateI64DynCallsPass() { return new GenerateDynCalls(true); } + +} // namespace wasm diff --git a/binaryen/src/passes/I64ToI32Lowering.cpp b/binaryen/src/passes/I64ToI32Lowering.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/passes/I64ToI32Lowering.cpp @@ -0,0 +1,1591 @@ +/* + * Copyright 2017 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// Lowers i64s to i32s by splitting variables and arguments +// into pairs of i32s. i64 return values are lowered by +// returning the low half and storing the high half into a +// global. +// + +#include "abi/js.h" +#include "asmjs/shared-constants.h" +#include "emscripten-optimizer/istring.h" +#include "ir/flat.h" +#include "ir/iteration.h" +#include "ir/memory-utils.h" +#include "ir/module-utils.h" +#include "ir/names.h" +#include "pass.h" +#include "support/name.h" +#include "wasm-builder.h" +#include "wasm.h" +#include + +namespace wasm { + +static Name makeHighName(Name n) { return std::string(n.c_str()) + "$hi"; } + +struct I64ToI32Lowering : public WalkerPass> { + struct TempVar { + TempVar(Index idx, Type ty, I64ToI32Lowering& pass) + : idx(idx), pass(pass), moved(false), ty(ty) {} + + TempVar(TempVar&& other) + : idx(other), pass(other.pass), moved(false), ty(other.ty) { + assert(!other.moved); + other.moved = true; + } + + TempVar& operator=(TempVar&& rhs) { + assert(!rhs.moved); + // free overwritten idx + if (!moved) { + freeIdx(); + } + idx = rhs.idx; + rhs.moved = true; + moved = false; + return *this; + } + + ~TempVar() { + if (!moved) { + freeIdx(); + } + } + + bool operator==(const TempVar& rhs) { + assert(!moved && !rhs.moved); + return idx == rhs.idx; + } + + operator Index() { + assert(!moved); + return idx; + } + + // disallow copying + TempVar(const TempVar&) = delete; + TempVar& operator=(const TempVar&) = delete; + + private: + void freeIdx() { + auto& freeList = pass.freeTemps[ty.getBasic()]; + assert(std::find(freeList.begin(), freeList.end(), idx) == + freeList.end()); + freeList.push_back(idx); + } + + Index idx; + I64ToI32Lowering& pass; + bool moved; // since C++ will still destruct moved-from values + Type ty; + }; + + // false since function types need to be lowered + // TODO: allow module-level transformations in parallel passes + bool isFunctionParallel() override { return false; } + + Pass* create() override { return new I64ToI32Lowering; } + + void doWalkModule(Module* module) { + if (!builder) { + builder = make_unique(*module); + } + // add new globals for high bits + for (size_t i = 0, globals = module->globals.size(); i < globals; ++i) { + auto* curr = module->globals[i].get(); + if (curr->type != Type::i64) { + continue; + } + originallyI64Globals.insert(curr->name); + curr->type = Type::i32; + auto* high = builder->makeGlobal(makeHighName(curr->name), + Type::i32, + builder->makeConst(int32_t(0)), + Builder::Mutable); + module->addGlobal(high); + if (curr->imported()) { + Fatal() << "TODO: imported i64 globals"; + } else { + if (auto* c = curr->init->dynCast()) { + uint64_t value = c->value.geti64(); + c->value = Literal(uint32_t(value)); + c->type = Type::i32; + high->init = builder->makeConst(uint32_t(value >> 32)); + } else if (auto* get = curr->init->dynCast()) { + high->init = + builder->makeGlobalGet(makeHighName(get->name), Type::i32); + } else { + WASM_UNREACHABLE("unexpected expression type"); + } + curr->init->type = Type::i32; + } + } + + // For functions that return 64-bit values, we use this global variable + // to return the high 32 bits. + auto* highBits = new Global(); + highBits->type = Type::i32; + highBits->name = INT64_TO_32_HIGH_BITS; + highBits->init = builder->makeConst(int32_t(0)); + highBits->mutable_ = true; + module->addGlobal(highBits); + PostWalker::doWalkModule(module); + } + + void doWalkFunction(Function* func) { + Flat::verifyFlatness(func); + // create builder here if this is first entry to module for this object + if (!builder) { + builder = make_unique(*getModule()); + } + indexMap.clear(); + highBitVars.clear(); + freeTemps.clear(); + Module temp; + auto* oldFunc = ModuleUtils::copyFunction(func, temp); + func->sig.params = Type::none; + func->vars.clear(); + func->localNames.clear(); + func->localIndices.clear(); + Index newIdx = 0; + Names::ensureNames(oldFunc); + for (Index i = 0; i < oldFunc->getNumLocals(); ++i) { + assert(oldFunc->hasLocalName(i)); + Name lowName = oldFunc->getLocalName(i); + Name highName = makeHighName(lowName); + Type paramType = oldFunc->getLocalType(i); + auto builderFunc = + (i < oldFunc->getVarIndexBase()) + ? Builder::addParam + : static_cast(Builder::addVar); + if (paramType == Type::i64) { + builderFunc(func, lowName, Type::i32); + builderFunc(func, highName, Type::i32); + indexMap[i] = newIdx; + newIdx += 2; + } else { + builderFunc(func, lowName, paramType); + indexMap[i] = newIdx++; + } + } + nextTemp = func->getNumLocals(); + PostWalker::doWalkFunction(func); + } + + void visitFunction(Function* func) { + if (func->imported()) { + return; + } + if (func->sig.results == Type::i64) { + func->sig.results = Type::i32; + // body may not have out param if it ends with control flow + if (hasOutParam(func->body)) { + TempVar highBits = fetchOutParam(func->body); + TempVar lowBits = getTemp(); + LocalSet* setLow = builder->makeLocalSet(lowBits, func->body); + GlobalSet* setHigh = builder->makeGlobalSet( + INT64_TO_32_HIGH_BITS, builder->makeLocalGet(highBits, Type::i32)); + LocalGet* getLow = builder->makeLocalGet(lowBits, Type::i32); + func->body = builder->blockify(setLow, setHigh, getLow); + } + } + int idx = 0; + for (size_t i = func->getNumLocals(); i < nextTemp; i++) { + Name tmpName("i64toi32_i32$" + std::to_string(idx++)); + builder->addVar(func, tmpName, tempTypes[i]); + } + } + + template + using BuilderFunc = std::function&, Type)>; + + // Fixes up a call. If we performed fixups, returns the call; otherwise + // returns nullptr; + template + T* visitGenericCall(T* curr, BuilderFunc callBuilder) { + bool fixed = false; + std::vector args; + for (auto* e : curr->operands) { + args.push_back(e); + if (hasOutParam(e)) { + TempVar argHighBits = fetchOutParam(e); + args.push_back(builder->makeLocalGet(argHighBits, Type::i32)); + fixed = true; + } + } + if (curr->type != Type::i64) { + auto* ret = callBuilder(args, curr->type); + replaceCurrent(ret); + return fixed ? ret : nullptr; + } + TempVar lowBits = getTemp(); + TempVar highBits = getTemp(); + auto* call = callBuilder(args, Type::i32); + LocalSet* doCall = builder->makeLocalSet(lowBits, call); + LocalSet* setHigh = builder->makeLocalSet( + highBits, builder->makeGlobalGet(INT64_TO_32_HIGH_BITS, Type::i32)); + LocalGet* getLow = builder->makeLocalGet(lowBits, Type::i32); + Block* result = builder->blockify(doCall, setHigh, getLow); + setOutParam(result, std::move(highBits)); + replaceCurrent(result); + return call; + } + void visitCall(Call* curr) { + if (curr->isReturn && + getModule()->getFunction(curr->target)->sig.results == Type::i64) { + Fatal() + << "i64 to i32 lowering of return_call values not yet implemented"; + } + auto* fixedCall = visitGenericCall( + curr, [&](std::vector& args, Type results) { + return builder->makeCall(curr->target, args, results, curr->isReturn); + }); + // If this was to an import, we need to call the legal version. This assumes + // that legalize-js-interface has been run before. + if (fixedCall && getModule()->getFunction(fixedCall->target)->imported()) { + fixedCall->target = std::string("legalfunc$") + fixedCall->target.str; + return; + } + } + + void visitCallIndirect(CallIndirect* curr) { + if (curr->isReturn && curr->sig.results == Type::i64) { + Fatal() + << "i64 to i32 lowering of return_call values not yet implemented"; + } + visitGenericCall( + curr, [&](std::vector& args, Type results) { + std::vector params; + for (const auto& param : curr->sig.params) { + if (param == Type::i64) { + params.push_back(Type::i32); + params.push_back(Type::i32); + } else { + params.push_back(param); + } + } + return builder->makeCallIndirect( + curr->target, args, Signature(Type(params), results), curr->isReturn); + }); + } + + void visitLocalGet(LocalGet* curr) { + const auto mappedIndex = indexMap[curr->index]; + // Need to remap the local into the new naming scheme, regardless of + // the type of the local. + curr->index = mappedIndex; + if (curr->type != Type::i64) { + return; + } + curr->type = Type::i32; + TempVar highBits = getTemp(); + LocalSet* setHighBits = builder->makeLocalSet( + highBits, builder->makeLocalGet(mappedIndex + 1, Type::i32)); + Block* result = builder->blockify(setHighBits, curr); + replaceCurrent(result); + setOutParam(result, std::move(highBits)); + } + + void lowerTee(LocalSet* curr) { + TempVar highBits = fetchOutParam(curr->value); + TempVar tmp = getTemp(); + curr->type = Type::i32; + LocalSet* setLow = builder->makeLocalSet(tmp, curr); + LocalSet* setHigh = builder->makeLocalSet( + curr->index + 1, builder->makeLocalGet(highBits, Type::i32)); + LocalGet* getLow = builder->makeLocalGet(tmp, Type::i32); + Block* result = builder->blockify(setLow, setHigh, getLow); + replaceCurrent(result); + setOutParam(result, std::move(highBits)); + } + + void visitLocalSet(LocalSet* curr) { + const auto mappedIndex = indexMap[curr->index]; + // Need to remap the local into the new naming scheme, regardless of + // the type of the local. Note that lowerTee depends on this happening. + curr->index = mappedIndex; + if (!hasOutParam(curr->value)) { + return; + } + if (curr->isTee()) { + lowerTee(curr); + return; + } + TempVar highBits = fetchOutParam(curr->value); + auto* setHigh = builder->makeLocalSet( + mappedIndex + 1, builder->makeLocalGet(highBits, Type::i32)); + Block* result = builder->blockify(curr, setHigh); + replaceCurrent(result); + } + + void visitGlobalGet(GlobalGet* curr) { + if (!getFunction()) { + return; // if in a global init, skip - we already handled that. + } + if (!originallyI64Globals.count(curr->name)) { + return; + } + curr->type = Type::i32; + TempVar highBits = getTemp(); + LocalSet* setHighBits = builder->makeLocalSet( + highBits, builder->makeGlobalGet(makeHighName(curr->name), Type::i32)); + Block* result = builder->blockify(setHighBits, curr); + replaceCurrent(result); + setOutParam(result, std::move(highBits)); + } + + void visitGlobalSet(GlobalSet* curr) { + if (!originallyI64Globals.count(curr->name)) { + return; + } + if (handleUnreachable(curr)) { + return; + } + TempVar highBits = fetchOutParam(curr->value); + auto* setHigh = builder->makeGlobalSet( + makeHighName(curr->name), builder->makeLocalGet(highBits, Type::i32)); + replaceCurrent(builder->makeSequence(curr, setHigh)); + } + + void visitLoad(Load* curr) { + if (curr->type != Type::i64) { + return; + } + assert(!curr->isAtomic && "64-bit atomic load not implemented"); + TempVar lowBits = getTemp(); + TempVar highBits = getTemp(); + TempVar ptrTemp = getTemp(); + LocalSet* setPtr = builder->makeLocalSet(ptrTemp, curr->ptr); + LocalSet* loadHigh; + if (curr->bytes == 8) { + loadHigh = builder->makeLocalSet( + highBits, + builder->makeLoad(4, + curr->signed_, + curr->offset + 4, + std::min(uint32_t(curr->align), uint32_t(4)), + builder->makeLocalGet(ptrTemp, Type::i32), + Type::i32)); + } else if (curr->signed_) { + loadHigh = builder->makeLocalSet( + highBits, + builder->makeBinary(ShrSInt32, + builder->makeLocalGet(lowBits, Type::i32), + builder->makeConst(int32_t(31)))); + } else { + loadHigh = + builder->makeLocalSet(highBits, builder->makeConst(int32_t(0))); + } + curr->type = Type::i32; + curr->bytes = std::min(curr->bytes, uint8_t(4)); + curr->align = std::min(uint32_t(curr->align), uint32_t(4)); + curr->ptr = builder->makeLocalGet(ptrTemp, Type::i32); + Block* result = + builder->blockify(setPtr, + builder->makeLocalSet(lowBits, curr), + loadHigh, + builder->makeLocalGet(lowBits, Type::i32)); + replaceCurrent(result); + setOutParam(result, std::move(highBits)); + } + + void visitStore(Store* curr) { + if (!hasOutParam(curr->value)) { + return; + } + assert(curr->offset + 4 > curr->offset); + assert(!curr->isAtomic && "atomic store not implemented"); + TempVar highBits = fetchOutParam(curr->value); + uint8_t bytes = curr->bytes; + curr->bytes = std::min(curr->bytes, uint8_t(4)); + curr->align = std::min(uint32_t(curr->align), uint32_t(4)); + curr->valueType = Type::i32; + if (bytes == 8) { + TempVar ptrTemp = getTemp(); + LocalSet* setPtr = builder->makeLocalSet(ptrTemp, curr->ptr); + curr->ptr = builder->makeLocalGet(ptrTemp, Type::i32); + curr->finalize(); + Store* storeHigh = + builder->makeStore(4, + curr->offset + 4, + std::min(uint32_t(curr->align), uint32_t(4)), + builder->makeLocalGet(ptrTemp, Type::i32), + builder->makeLocalGet(highBits, Type::i32), + Type::i32); + replaceCurrent(builder->blockify(setPtr, curr, storeHigh)); + } + } + + void visitAtomicRMW(AtomicRMW* curr) { + if (handleUnreachable(curr)) { + return; + } + if (curr->type != Type::i64) { + return; + } + // We cannot break this up into smaller operations as it must be atomic. + // Lower to an instrinsic function that wasm2js will implement. + TempVar lowBits = getTemp(); + TempVar highBits = getTemp(); + auto* getLow = builder->makeCall( + ABI::wasm2js::ATOMIC_RMW_I64, + {builder->makeConst(int32_t(curr->op)), + builder->makeConst(int32_t(curr->bytes)), + builder->makeConst(int32_t(curr->offset)), + curr->ptr, + curr->value, + builder->makeLocalGet(fetchOutParam(curr->value), Type::i32)}, + Type::i32); + auto* getHigh = + builder->makeCall(ABI::wasm2js::GET_STASHED_BITS, {}, Type::i32); + auto* setLow = builder->makeLocalSet(lowBits, getLow); + auto* setHigh = builder->makeLocalSet(highBits, getHigh); + auto* finalGet = builder->makeLocalGet(lowBits, Type::i32); + auto* result = builder->makeBlock({setLow, setHigh, finalGet}); + setOutParam(result, std::move(highBits)); + replaceCurrent(result); + } + + void visitAtomicCmpxchg(AtomicCmpxchg* curr) { + assert(curr->type != Type::i64 && "64-bit AtomicCmpxchg not implemented"); + } + + void visitAtomicWait(AtomicWait* curr) { + // The last parameter is an i64, so we cannot leave it as it is + assert(curr->offset == 0); + replaceCurrent(builder->makeCall( + ABI::wasm2js::ATOMIC_WAIT_I32, + {curr->ptr, + curr->expected, + curr->timeout, + builder->makeLocalGet(fetchOutParam(curr->timeout), Type::i32)}, + Type::i32)); + } + + void visitConst(Const* curr) { + if (!getFunction()) { + return; // if in a global init, skip - we already handled that. + } + if (curr->type != Type::i64) { + return; + } + TempVar highBits = getTemp(); + Const* lowVal = + builder->makeConst(int32_t(curr->value.geti64() & 0xffffffff)); + LocalSet* setHigh = builder->makeLocalSet( + highBits, + builder->makeConst(int32_t(uint64_t(curr->value.geti64()) >> 32))); + Block* result = builder->blockify(setHigh, lowVal); + setOutParam(result, std::move(highBits)); + replaceCurrent(result); + } + + void lowerEqZInt64(Unary* curr) { + TempVar highBits = fetchOutParam(curr->value); + + auto* result = builder->makeUnary( + EqZInt32, + builder->makeBinary( + OrInt32, curr->value, builder->makeLocalGet(highBits, Type::i32))); + + replaceCurrent(result); + } + + void lowerExtendUInt32(Unary* curr) { + TempVar highBits = getTemp(); + Block* result = builder->blockify( + builder->makeLocalSet(highBits, builder->makeConst(int32_t(0))), + curr->value); + setOutParam(result, std::move(highBits)); + replaceCurrent(result); + } + + void lowerExtendSInt32(Unary* curr) { + TempVar highBits = getTemp(); + TempVar lowBits = getTemp(); + + LocalSet* setLow = builder->makeLocalSet(lowBits, curr->value); + LocalSet* setHigh = builder->makeLocalSet( + highBits, + builder->makeBinary(ShrSInt32, + builder->makeLocalGet(lowBits, Type::i32), + builder->makeConst(int32_t(31)))); + + Block* result = builder->blockify( + setLow, setHigh, builder->makeLocalGet(lowBits, Type::i32)); + + setOutParam(result, std::move(highBits)); + replaceCurrent(result); + } + + void lowerWrapInt64(Unary* curr) { + // free the temp var + fetchOutParam(curr->value); + replaceCurrent(curr->value); + } + + void lowerReinterpretFloat64(Unary* curr) { + // Assume that the wasm file assumes the address 0 is invalid and roundtrip + // our f64 through memory at address 0 + TempVar highBits = getTemp(); + Block* result = builder->blockify( + builder->makeCall( + ABI::wasm2js::SCRATCH_STORE_F64, {curr->value}, Type::none), + builder->makeLocalSet(highBits, + builder->makeCall(ABI::wasm2js::SCRATCH_LOAD_I32, + {builder->makeConst(int32_t(1))}, + Type::i32)), + builder->makeCall(ABI::wasm2js::SCRATCH_LOAD_I32, + {builder->makeConst(int32_t(0))}, + Type::i32)); + setOutParam(result, std::move(highBits)); + replaceCurrent(result); + MemoryUtils::ensureExists(getModule()->memory); + ABI::wasm2js::ensureHelpers(getModule()); + } + + void lowerReinterpretInt64(Unary* curr) { + // Assume that the wasm file assumes the address 0 is invalid and roundtrip + // our i64 through memory at address 0 + TempVar highBits = fetchOutParam(curr->value); + Block* result = builder->blockify( + builder->makeCall(ABI::wasm2js::SCRATCH_STORE_I32, + {builder->makeConst(int32_t(0)), curr->value}, + Type::none), + builder->makeCall(ABI::wasm2js::SCRATCH_STORE_I32, + {builder->makeConst(int32_t(1)), + builder->makeLocalGet(highBits, Type::i32)}, + Type::none), + builder->makeCall(ABI::wasm2js::SCRATCH_LOAD_F64, {}, Type::f64)); + replaceCurrent(result); + MemoryUtils::ensureExists(getModule()->memory); + ABI::wasm2js::ensureHelpers(getModule()); + } + + void lowerTruncFloatToInt(Unary* curr) { + // hiBits = if abs(f) >= 1.0 { + // if f > 0.0 { + // (unsigned) min( + // floor(f / (float) U32_MAX), + // (float) U32_MAX - 1, + // ) + // } else { + // (unsigned) ceil((f - (float) (unsigned) f) / ((float) U32_MAX)) + // } + // } else { + // 0 + // } + // + // loBits = (unsigned) f; + + Literal litZero, litOne, u32Max; + UnaryOp trunc, convert, abs, floor, ceil; + Type localType; + BinaryOp ge, gt, min, div, sub; + switch (curr->op) { + case TruncSFloat32ToInt64: + case TruncUFloat32ToInt64: { + litZero = Literal((float)0); + litOne = Literal((float)1); + u32Max = Literal(((float)UINT_MAX) + 1); + trunc = TruncUFloat32ToInt32; + convert = ConvertUInt32ToFloat32; + localType = Type::f32; + abs = AbsFloat32; + ge = GeFloat32; + gt = GtFloat32; + min = MinFloat32; + floor = FloorFloat32; + ceil = CeilFloat32; + div = DivFloat32; + sub = SubFloat32; + break; + } + case TruncSFloat64ToInt64: + case TruncUFloat64ToInt64: { + litZero = Literal((double)0); + litOne = Literal((double)1); + u32Max = Literal(((double)UINT_MAX) + 1); + trunc = TruncUFloat64ToInt32; + convert = ConvertUInt32ToFloat64; + localType = Type::f64; + abs = AbsFloat64; + ge = GeFloat64; + gt = GtFloat64; + min = MinFloat64; + floor = FloorFloat64; + ceil = CeilFloat64; + div = DivFloat64; + sub = SubFloat64; + break; + } + default: + abort(); + } + + TempVar f = getTemp(localType); + TempVar highBits = getTemp(); + + Expression* gtZeroBranch = builder->makeBinary( + min, + builder->makeUnary( + floor, + builder->makeBinary(div, + builder->makeLocalGet(f, localType), + builder->makeConst(u32Max))), + builder->makeBinary( + sub, builder->makeConst(u32Max), builder->makeConst(litOne))); + Expression* ltZeroBranch = builder->makeUnary( + ceil, + builder->makeBinary( + div, + builder->makeBinary( + sub, + builder->makeLocalGet(f, localType), + builder->makeUnary( + convert, + builder->makeUnary(trunc, builder->makeLocalGet(f, localType)))), + builder->makeConst(u32Max))); + + If* highBitsCalc = builder->makeIf( + builder->makeBinary( + gt, builder->makeLocalGet(f, localType), builder->makeConst(litZero)), + builder->makeUnary(trunc, gtZeroBranch), + builder->makeUnary(trunc, ltZeroBranch)); + If* highBitsVal = builder->makeIf( + builder->makeBinary( + ge, + builder->makeUnary(abs, builder->makeLocalGet(f, localType)), + builder->makeConst(litOne)), + highBitsCalc, + builder->makeConst(int32_t(0))); + Block* result = builder->blockify( + builder->makeLocalSet(f, curr->value), + builder->makeLocalSet(highBits, highBitsVal), + builder->makeUnary(trunc, builder->makeLocalGet(f, localType))); + setOutParam(result, std::move(highBits)); + replaceCurrent(result); + } + + void lowerConvertIntToFloat(Unary* curr) { + // Here the same strategy as `emcc` is taken which takes the two halves of + // the 64-bit integer and creates a mathematical expression using float + // arithmetic to reassemble the final floating point value. + // + // For example for i64 -> f32 we generate: + // + // ((double) (unsigned) lowBits) + + // ((double) U32_MAX) * ((double) (int) highBits) + // + // Mostly just shuffling things around here with coercions and whatnot! + // Note though that all arithmetic is done with f64 to have as much + // precision as we can. + // + // NB: this is *not* accurate for i64 -> f32. Using f64s for intermediate + // operations can give slightly inaccurate results in some cases, as we + // round to an f64, then round again to an f32, which is not always the + // same as a single rounding of i64 to f32 directly. Example: + // + // #include + // int main() { + // unsigned long long x = 18446743523953737727ULL; + // float y = x; + // double z = x; + // float w = z; + // printf("i64 : %llu\n" + // "i64->f32 : %f\n" + // "i64->f64 : %f\n" + // "i64->f64->f32: %f\n", x, y, z, w); + // } + // + // i64 : 18446743523953737727 + // i64->f32 : 18446742974197923840.000000 ;; correct rounding to f32 + // i64->f64 : 18446743523953737728.000000 ;; correct rounding to f64 + // i64->f64->f32: 18446744073709551616.000000 ;; incorrect rounding to f32 + // + // This is even a problem if we use BigInts in JavaScript to represent + // i64s, as Math.fround(BigInt) is not supported - the BigInt must be + // converted to a Number first, so we again have that extra rounding. + // + // A more precise approach could use compiled floatdisf/floatundisf from + // compiler-rt, but that is much larger and slower. (Note that we are in the + // interesting situation of having f32 and f64 operations and only missing + // i64 ones, so we have a different problem to solve than compiler-rt, and + // maybe there is a better solution we haven't found yet.) + TempVar highBits = fetchOutParam(curr->value); + TempVar lowBits = getTemp(); + TempVar highResult = getTemp(); + + UnaryOp convertHigh; + switch (curr->op) { + case ConvertSInt64ToFloat32: + case ConvertSInt64ToFloat64: + convertHigh = ConvertSInt32ToFloat64; + break; + case ConvertUInt64ToFloat32: + case ConvertUInt64ToFloat64: + convertHigh = ConvertUInt32ToFloat64; + break; + default: + abort(); + } + + Expression* result = builder->blockify( + builder->makeLocalSet(lowBits, curr->value), + builder->makeLocalSet(highResult, builder->makeConst(int32_t(0))), + builder->makeBinary( + AddFloat64, + builder->makeUnary(ConvertUInt32ToFloat64, + builder->makeLocalGet(lowBits, Type::i32)), + builder->makeBinary( + MulFloat64, + builder->makeConst((double)UINT_MAX + 1), + builder->makeUnary(convertHigh, + builder->makeLocalGet(highBits, Type::i32))))); + + switch (curr->op) { + case ConvertSInt64ToFloat32: + case ConvertUInt64ToFloat32: { + result = builder->makeUnary(DemoteFloat64, result); + break; + } + default: + break; + } + + replaceCurrent(result); + } + + void lowerCountZeros(Unary* curr) { + auto lower = [&](Block* result, + UnaryOp op32, + TempVar&& first, + TempVar&& second) { + TempVar highResult = getTemp(); + TempVar firstResult = getTemp(); + LocalSet* setFirst = builder->makeLocalSet( + firstResult, + builder->makeUnary(op32, builder->makeLocalGet(first, Type::i32))); + + Binary* check = + builder->makeBinary(EqInt32, + builder->makeLocalGet(firstResult, Type::i32), + builder->makeConst(int32_t(32))); + + If* conditional = builder->makeIf( + check, + builder->makeBinary( + AddInt32, + builder->makeUnary(op32, builder->makeLocalGet(second, Type::i32)), + builder->makeConst(int32_t(32))), + builder->makeLocalGet(firstResult, Type::i32)); + + LocalSet* setHigh = + builder->makeLocalSet(highResult, builder->makeConst(int32_t(0))); + + setOutParam(result, std::move(highResult)); + + replaceCurrent(builder->blockify(result, setFirst, setHigh, conditional)); + }; + + TempVar highBits = fetchOutParam(curr->value); + TempVar lowBits = getTemp(); + LocalSet* setLow = builder->makeLocalSet(lowBits, curr->value); + Block* result = builder->blockify(setLow); + + switch (curr->op) { + case ClzInt64: + lower(result, ClzInt32, std::move(highBits), std::move(lowBits)); + break; + case CtzInt64: + WASM_UNREACHABLE("i64.ctz should be removed already"); + break; + default: + abort(); + } + } + + bool unaryNeedsLowering(UnaryOp op) { + switch (op) { + case ClzInt64: + case CtzInt64: + case PopcntInt64: + case EqZInt64: + case ExtendSInt32: + case ExtendUInt32: + case WrapInt64: + case TruncSFloat32ToInt64: + case TruncUFloat32ToInt64: + case TruncSFloat64ToInt64: + case TruncUFloat64ToInt64: + case ReinterpretFloat64: + case ConvertSInt64ToFloat32: + case ConvertSInt64ToFloat64: + case ConvertUInt64ToFloat32: + case ConvertUInt64ToFloat64: + case ReinterpretInt64: + return true; + default: + return false; + } + } + + void visitUnary(Unary* curr) { + if (!unaryNeedsLowering(curr->op)) { + return; + } + if (handleUnreachable(curr)) { + return; + } + assert(hasOutParam(curr->value) || curr->type == Type::i64 || + curr->type == Type::f64); + switch (curr->op) { + case ClzInt64: + case CtzInt64: + lowerCountZeros(curr); + break; + case EqZInt64: + lowerEqZInt64(curr); + break; + case ExtendSInt32: + lowerExtendSInt32(curr); + break; + case ExtendUInt32: + lowerExtendUInt32(curr); + break; + case WrapInt64: + lowerWrapInt64(curr); + break; + case ReinterpretFloat64: + lowerReinterpretFloat64(curr); + break; + case ReinterpretInt64: + lowerReinterpretInt64(curr); + break; + case TruncSFloat32ToInt64: + case TruncUFloat32ToInt64: + case TruncSFloat64ToInt64: + case TruncUFloat64ToInt64: + lowerTruncFloatToInt(curr); + break; + case ConvertSInt64ToFloat32: + case ConvertSInt64ToFloat64: + case ConvertUInt64ToFloat32: + case ConvertUInt64ToFloat64: + lowerConvertIntToFloat(curr); + break; + case PopcntInt64: + WASM_UNREACHABLE("i64.popcnt should already be removed"); + default: + std::cerr << "Unhandled unary operator: " << curr->op << std::endl; + abort(); + } + } + + Block* lowerAdd(Block* result, + TempVar&& leftLow, + TempVar&& leftHigh, + TempVar&& rightLow, + TempVar&& rightHigh) { + TempVar lowResult = getTemp(); + TempVar highResult = getTemp(); + LocalSet* addLow = builder->makeLocalSet( + lowResult, + builder->makeBinary(AddInt32, + builder->makeLocalGet(leftLow, Type::i32), + builder->makeLocalGet(rightLow, Type::i32))); + LocalSet* addHigh = builder->makeLocalSet( + highResult, + builder->makeBinary(AddInt32, + builder->makeLocalGet(leftHigh, Type::i32), + builder->makeLocalGet(rightHigh, Type::i32))); + LocalSet* carryBit = builder->makeLocalSet( + highResult, + builder->makeBinary(AddInt32, + builder->makeLocalGet(highResult, Type::i32), + builder->makeConst(int32_t(1)))); + If* checkOverflow = builder->makeIf( + builder->makeBinary(LtUInt32, + builder->makeLocalGet(lowResult, Type::i32), + builder->makeLocalGet(rightLow, Type::i32)), + carryBit); + LocalGet* getLow = builder->makeLocalGet(lowResult, Type::i32); + result = builder->blockify(result, addLow, addHigh, checkOverflow, getLow); + setOutParam(result, std::move(highResult)); + return result; + } + + Block* lowerSub(Block* result, + TempVar&& leftLow, + TempVar&& leftHigh, + TempVar&& rightLow, + TempVar&& rightHigh) { + TempVar lowResult = getTemp(); + TempVar highResult = getTemp(); + TempVar borrow = getTemp(); + LocalSet* subLow = builder->makeLocalSet( + lowResult, + builder->makeBinary(SubInt32, + builder->makeLocalGet(leftLow, Type::i32), + builder->makeLocalGet(rightLow, Type::i32))); + LocalSet* borrowBit = builder->makeLocalSet( + borrow, + builder->makeBinary(LtUInt32, + builder->makeLocalGet(leftLow, Type::i32), + builder->makeLocalGet(rightLow, Type::i32))); + LocalSet* subHigh1 = builder->makeLocalSet( + highResult, + builder->makeBinary(AddInt32, + builder->makeLocalGet(borrow, Type::i32), + builder->makeLocalGet(rightHigh, Type::i32))); + LocalSet* subHigh2 = builder->makeLocalSet( + highResult, + builder->makeBinary(SubInt32, + builder->makeLocalGet(leftHigh, Type::i32), + builder->makeLocalGet(highResult, Type::i32))); + LocalGet* getLow = builder->makeLocalGet(lowResult, Type::i32); + result = + builder->blockify(result, subLow, borrowBit, subHigh1, subHigh2, getLow); + setOutParam(result, std::move(highResult)); + return result; + } + + Block* lowerBitwise(BinaryOp op, + Block* result, + TempVar&& leftLow, + TempVar&& leftHigh, + TempVar&& rightLow, + TempVar&& rightHigh) { + BinaryOp op32; + switch (op) { + case AndInt64: + op32 = AndInt32; + break; + case OrInt64: + op32 = OrInt32; + break; + case XorInt64: + op32 = XorInt32; + break; + default: + abort(); + } + result = builder->blockify( + result, + builder->makeLocalSet( + rightHigh, + builder->makeBinary(op32, + builder->makeLocalGet(leftHigh, Type::i32), + builder->makeLocalGet(rightHigh, Type::i32))), + builder->makeBinary(op32, + builder->makeLocalGet(leftLow, Type::i32), + builder->makeLocalGet(rightLow, Type::i32))); + setOutParam(result, std::move(rightHigh)); + return result; + } + + Block* makeLargeShl(Index highBits, Index leftLow, Index shift) { + return builder->blockify( + builder->makeLocalSet( + highBits, + builder->makeBinary(ShlInt32, + builder->makeLocalGet(leftLow, Type::i32), + builder->makeLocalGet(shift, Type::i32))), + builder->makeConst(int32_t(0))); + } + + // a >> b where `b` >= 32 + // + // implement as: + // + // hi = leftHigh >> 31 // copy sign bit + // lo = leftHigh >> (b - 32) + Block* makeLargeShrS(Index highBits, Index leftHigh, Index shift) { + return builder->blockify( + builder->makeLocalSet( + highBits, + builder->makeBinary(ShrSInt32, + builder->makeLocalGet(leftHigh, Type::i32), + builder->makeConst(int32_t(31)))), + builder->makeBinary(ShrSInt32, + builder->makeLocalGet(leftHigh, Type::i32), + builder->makeLocalGet(shift, Type::i32))); + } + + Block* makeLargeShrU(Index highBits, Index leftHigh, Index shift) { + return builder->blockify( + builder->makeLocalSet(highBits, builder->makeConst(int32_t(0))), + builder->makeBinary(ShrUInt32, + builder->makeLocalGet(leftHigh, Type::i32), + builder->makeLocalGet(shift, Type::i32))); + } + + Block* makeSmallShl(Index highBits, + Index leftLow, + Index leftHigh, + Index shift, + Binary* shiftMask, + Binary* widthLessShift) { + Binary* shiftedInBits = builder->makeBinary( + AndInt32, + shiftMask, + builder->makeBinary( + ShrUInt32, builder->makeLocalGet(leftLow, Type::i32), widthLessShift)); + Binary* shiftHigh = + builder->makeBinary(ShlInt32, + builder->makeLocalGet(leftHigh, Type::i32), + builder->makeLocalGet(shift, Type::i32)); + return builder->blockify( + builder->makeLocalSet( + highBits, builder->makeBinary(OrInt32, shiftedInBits, shiftHigh)), + builder->makeBinary(ShlInt32, + builder->makeLocalGet(leftLow, Type::i32), + builder->makeLocalGet(shift, Type::i32))); + } + + // a >> b where `b` < 32 + // + // implement as: + // + // hi = leftHigh >> b + // lo = (leftLow >>> b) | (leftHigh << (32 - b)) + Block* makeSmallShrS(Index highBits, + Index leftLow, + Index leftHigh, + Index shift, + Binary* shiftMask, + Binary* widthLessShift) { + Binary* shiftedInBits = builder->makeBinary( + ShlInt32, + builder->makeBinary( + AndInt32, shiftMask, builder->makeLocalGet(leftHigh, Type::i32)), + widthLessShift); + Binary* shiftLow = + builder->makeBinary(ShrUInt32, + builder->makeLocalGet(leftLow, Type::i32), + builder->makeLocalGet(shift, Type::i32)); + return builder->blockify( + builder->makeLocalSet( + highBits, + builder->makeBinary(ShrSInt32, + builder->makeLocalGet(leftHigh, Type::i32), + builder->makeLocalGet(shift, Type::i32))), + builder->makeBinary(OrInt32, shiftedInBits, shiftLow)); + } + + Block* makeSmallShrU(Index highBits, + Index leftLow, + Index leftHigh, + Index shift, + Binary* shiftMask, + Binary* widthLessShift) { + Binary* shiftedInBits = builder->makeBinary( + ShlInt32, + builder->makeBinary( + AndInt32, shiftMask, builder->makeLocalGet(leftHigh, Type::i32)), + widthLessShift); + Binary* shiftLow = + builder->makeBinary(ShrUInt32, + builder->makeLocalGet(leftLow, Type::i32), + builder->makeLocalGet(shift, Type::i32)); + return builder->blockify( + builder->makeLocalSet( + highBits, + builder->makeBinary(ShrUInt32, + builder->makeLocalGet(leftHigh, Type::i32), + builder->makeLocalGet(shift, Type::i32))), + builder->makeBinary(OrInt32, shiftedInBits, shiftLow)); + } + + Block* lowerShift(BinaryOp op, + Block* result, + TempVar&& leftLow, + TempVar&& leftHigh, + TempVar&& rightLow, + TempVar&& rightHigh) { + assert(op == ShlInt64 || op == ShrUInt64 || op == ShrSInt64); + // shift left lowered as: + // if 32 <= rightLow % 64: + // high = leftLow << k; low = 0 + // else: + // high = (((1 << k) - 1) & (leftLow >> (32 - k))) | (leftHigh << k); + // low = leftLow << k + // where k = shift % 32. shift right is similar. + TempVar shift = getTemp(); + LocalSet* setShift = builder->makeLocalSet( + shift, + builder->makeBinary(AndInt32, + builder->makeLocalGet(rightLow, Type::i32), + builder->makeConst(int32_t(32 - 1)))); + Binary* isLargeShift = builder->makeBinary( + LeUInt32, + builder->makeConst(int32_t(32)), + builder->makeBinary(AndInt32, + builder->makeLocalGet(rightLow, Type::i32), + builder->makeConst(int32_t(64 - 1)))); + Block* largeShiftBlock; + switch (op) { + case ShlInt64: + largeShiftBlock = makeLargeShl(rightHigh, leftLow, shift); + break; + case ShrSInt64: + largeShiftBlock = makeLargeShrS(rightHigh, leftHigh, shift); + break; + case ShrUInt64: + largeShiftBlock = makeLargeShrU(rightHigh, leftHigh, shift); + break; + default: + abort(); + } + Binary* shiftMask = builder->makeBinary( + SubInt32, + builder->makeBinary(ShlInt32, + builder->makeConst(int32_t(1)), + builder->makeLocalGet(shift, Type::i32)), + builder->makeConst(int32_t(1))); + Binary* widthLessShift = + builder->makeBinary(SubInt32, + builder->makeConst(int32_t(32)), + builder->makeLocalGet(shift, Type::i32)); + Block* smallShiftBlock; + switch (op) { + case ShlInt64: { + smallShiftBlock = makeSmallShl( + rightHigh, leftLow, leftHigh, shift, shiftMask, widthLessShift); + break; + } + case ShrSInt64: { + smallShiftBlock = makeSmallShrS( + rightHigh, leftLow, leftHigh, shift, shiftMask, widthLessShift); + break; + } + case ShrUInt64: { + smallShiftBlock = makeSmallShrU( + rightHigh, leftLow, leftHigh, shift, shiftMask, widthLessShift); + break; + } + default: + abort(); + } + If* ifLargeShift = + builder->makeIf(isLargeShift, largeShiftBlock, smallShiftBlock); + result = builder->blockify(result, setShift, ifLargeShift); + setOutParam(result, std::move(rightHigh)); + return result; + } + + Block* lowerEq(Block* result, + TempVar&& leftLow, + TempVar&& leftHigh, + TempVar&& rightLow, + TempVar&& rightHigh) { + return builder->blockify( + result, + builder->makeBinary( + AndInt32, + builder->makeBinary(EqInt32, + builder->makeLocalGet(leftLow, Type::i32), + builder->makeLocalGet(rightLow, Type::i32)), + builder->makeBinary(EqInt32, + builder->makeLocalGet(leftHigh, Type::i32), + builder->makeLocalGet(rightHigh, Type::i32)))); + } + + Block* lowerNe(Block* result, + TempVar&& leftLow, + TempVar&& leftHigh, + TempVar&& rightLow, + TempVar&& rightHigh) { + return builder->blockify( + result, + builder->makeBinary( + OrInt32, + builder->makeBinary(NeInt32, + builder->makeLocalGet(leftLow, Type::i32), + builder->makeLocalGet(rightLow, Type::i32)), + builder->makeBinary(NeInt32, + builder->makeLocalGet(leftHigh, Type::i32), + builder->makeLocalGet(rightHigh, Type::i32)))); + } + + Block* lowerUComp(BinaryOp op, + Block* result, + TempVar&& leftLow, + TempVar&& leftHigh, + TempVar&& rightLow, + TempVar&& rightHigh) { + BinaryOp highOp, lowOp; + switch (op) { + case LtUInt64: + highOp = LtUInt32; + lowOp = LtUInt32; + break; + case LeUInt64: + highOp = LtUInt32; + lowOp = LeUInt32; + break; + case GtUInt64: + highOp = GtUInt32; + lowOp = GtUInt32; + break; + case GeUInt64: + highOp = GtUInt32; + lowOp = GeUInt32; + break; + default: + abort(); + } + Binary* compHigh = + builder->makeBinary(highOp, + builder->makeLocalGet(leftHigh, Type::i32), + builder->makeLocalGet(rightHigh, Type::i32)); + Binary* eqHigh = + builder->makeBinary(EqInt32, + builder->makeLocalGet(leftHigh, Type::i32), + builder->makeLocalGet(rightHigh, Type::i32)); + Binary* compLow = + builder->makeBinary(lowOp, + builder->makeLocalGet(leftLow, Type::i32), + builder->makeLocalGet(rightLow, Type::i32)); + return builder->blockify( + result, + builder->makeBinary( + OrInt32, compHigh, builder->makeBinary(AndInt32, eqHigh, compLow))); + } + + Block* lowerSComp(BinaryOp op, + Block* result, + TempVar&& leftLow, + TempVar&& leftHigh, + TempVar&& rightLow, + TempVar&& rightHigh) { + BinaryOp highOp1, highOp2, lowOp; + switch (op) { + case LtSInt64: + highOp1 = LtSInt32; + highOp2 = LeSInt32; + lowOp = GeUInt32; + break; + case LeSInt64: + highOp1 = LtSInt32; + highOp2 = LeSInt32; + lowOp = GtUInt32; + break; + case GtSInt64: + highOp1 = GtSInt32; + highOp2 = GeSInt32; + lowOp = LeUInt32; + break; + case GeSInt64: + highOp1 = GtSInt32; + highOp2 = GeSInt32; + lowOp = LtUInt32; + break; + default: + abort(); + } + Binary* compHigh1 = + builder->makeBinary(highOp1, + builder->makeLocalGet(leftHigh, Type::i32), + builder->makeLocalGet(rightHigh, Type::i32)); + Binary* compHigh2 = + builder->makeBinary(highOp2, + builder->makeLocalGet(leftHigh, Type::i32), + builder->makeLocalGet(rightHigh, Type::i32)); + Binary* compLow = + builder->makeBinary(lowOp, + builder->makeLocalGet(leftLow, Type::i32), + builder->makeLocalGet(rightLow, Type::i32)); + If* lowIf = builder->makeIf( + compLow, builder->makeConst(int32_t(0)), builder->makeConst(int32_t(1))); + If* highIf2 = + builder->makeIf(compHigh2, lowIf, builder->makeConst(int32_t(0))); + If* highIf1 = + builder->makeIf(compHigh1, builder->makeConst(int32_t(1)), highIf2); + return builder->blockify(result, highIf1); + } + + bool binaryNeedsLowering(BinaryOp op) { + switch (op) { + case AddInt64: + case SubInt64: + case MulInt64: + case DivSInt64: + case DivUInt64: + case RemSInt64: + case RemUInt64: + case AndInt64: + case OrInt64: + case XorInt64: + case ShlInt64: + case ShrUInt64: + case ShrSInt64: + case RotLInt64: + case RotRInt64: + case EqInt64: + case NeInt64: + case LtSInt64: + case LtUInt64: + case LeSInt64: + case LeUInt64: + case GtSInt64: + case GtUInt64: + case GeSInt64: + case GeUInt64: + return true; + default: + return false; + } + } + + void visitBinary(Binary* curr) { + if (handleUnreachable(curr)) { + return; + } + if (!binaryNeedsLowering(curr->op)) { + return; + } + // left and right reachable, lower normally + TempVar leftLow = getTemp(); + TempVar leftHigh = fetchOutParam(curr->left); + TempVar rightLow = getTemp(); + TempVar rightHigh = fetchOutParam(curr->right); + LocalSet* setRight = builder->makeLocalSet(rightLow, curr->right); + LocalSet* setLeft = builder->makeLocalSet(leftLow, curr->left); + Block* result = builder->blockify(setLeft, setRight); + switch (curr->op) { + case AddInt64: { + replaceCurrent(lowerAdd(result, + std::move(leftLow), + std::move(leftHigh), + std::move(rightLow), + std::move(rightHigh))); + break; + } + case SubInt64: { + replaceCurrent(lowerSub(result, + std::move(leftLow), + std::move(leftHigh), + std::move(rightLow), + std::move(rightHigh))); + break; + } + case MulInt64: + case DivSInt64: + case DivUInt64: + case RemSInt64: + case RemUInt64: + case RotLInt64: + case RotRInt64: + WASM_UNREACHABLE("should have been removed by now"); + + case AndInt64: + case OrInt64: + case XorInt64: { + replaceCurrent(lowerBitwise(curr->op, + result, + std::move(leftLow), + std::move(leftHigh), + std::move(rightLow), + std::move(rightHigh))); + break; + } + case ShlInt64: + case ShrSInt64: + case ShrUInt64: { + replaceCurrent(lowerShift(curr->op, + result, + std::move(leftLow), + std::move(leftHigh), + std::move(rightLow), + std::move(rightHigh))); + break; + } + case EqInt64: { + replaceCurrent(lowerEq(result, + std::move(leftLow), + std::move(leftHigh), + std::move(rightLow), + std::move(rightHigh))); + break; + } + case NeInt64: { + replaceCurrent(lowerNe(result, + std::move(leftLow), + std::move(leftHigh), + std::move(rightLow), + std::move(rightHigh))); + break; + } + case LtSInt64: + case LeSInt64: + case GtSInt64: + case GeSInt64: + replaceCurrent(lowerSComp(curr->op, + result, + std::move(leftLow), + std::move(leftHigh), + std::move(rightLow), + std::move(rightHigh))); + break; + case LtUInt64: + case LeUInt64: + case GtUInt64: + case GeUInt64: { + replaceCurrent(lowerUComp(curr->op, + result, + std::move(leftLow), + std::move(leftHigh), + std::move(rightLow), + std::move(rightHigh))); + break; + } + default: { + std::cerr << "Unhandled binary op " << curr->op << std::endl; + abort(); + } + } + } + + void visitSelect(Select* curr) { + if (handleUnreachable(curr)) { + return; + } + if (!hasOutParam(curr->ifTrue)) { + assert(!hasOutParam(curr->ifFalse)); + return; + } + assert(hasOutParam(curr->ifFalse)); + TempVar highBits = getTemp(); + TempVar lowBits = getTemp(); + TempVar cond = getTemp(); + Block* result = builder->blockify( + builder->makeLocalSet(cond, curr->condition), + builder->makeLocalSet( + lowBits, + builder->makeSelect( + builder->makeLocalGet(cond, Type::i32), curr->ifTrue, curr->ifFalse)), + builder->makeLocalSet( + highBits, + builder->makeSelect( + builder->makeLocalGet(cond, Type::i32), + builder->makeLocalGet(fetchOutParam(curr->ifTrue), Type::i32), + builder->makeLocalGet(fetchOutParam(curr->ifFalse), Type::i32))), + builder->makeLocalGet(lowBits, Type::i32)); + setOutParam(result, std::move(highBits)); + replaceCurrent(result); + } + + void visitDrop(Drop* curr) { + if (!hasOutParam(curr->value)) { + return; + } + // free temp var + fetchOutParam(curr->value); + } + + void visitReturn(Return* curr) { + if (!hasOutParam(curr->value)) { + return; + } + TempVar lowBits = getTemp(); + TempVar highBits = fetchOutParam(curr->value); + LocalSet* setLow = builder->makeLocalSet(lowBits, curr->value); + GlobalSet* setHigh = builder->makeGlobalSet( + INT64_TO_32_HIGH_BITS, builder->makeLocalGet(highBits, Type::i32)); + curr->value = builder->makeLocalGet(lowBits, Type::i32); + Block* result = builder->blockify(setLow, setHigh, curr); + replaceCurrent(result); + } + +private: + std::unique_ptr builder; + std::unordered_map indexMap; + std::unordered_map> freeTemps; + std::unordered_map highBitVars; + std::unordered_map tempTypes; + std::unordered_set originallyI64Globals; + Index nextTemp; + + TempVar getTemp(Type ty = Type::i32) { + Index ret; + auto& freeList = freeTemps[ty.getBasic()]; + if (freeList.size() > 0) { + ret = freeList.back(); + freeList.pop_back(); + } else { + ret = nextTemp++; + tempTypes[ret] = ty; + } + assert(tempTypes[ret] == ty); + return TempVar(ret, ty, *this); + } + + bool hasOutParam(Expression* e) { + return highBitVars.find(e) != highBitVars.end(); + } + + void setOutParam(Expression* e, TempVar&& var) { + highBitVars.emplace(e, std::move(var)); + } + + TempVar fetchOutParam(Expression* e) { + auto outParamIt = highBitVars.find(e); + assert(outParamIt != highBitVars.end()); + TempVar ret = std::move(outParamIt->second); + highBitVars.erase(e); + return ret; + } + + // If e.g. a select is unreachable, then one arm may have an out param + // but not the other. In this case dce should really have been run + // before; handle it in a simple way here by replacing the node with + // a block of its children. + // This is valid only for nodes that execute their children + // unconditionally before themselves, so it is not valid for an if, + // in particular. + bool handleUnreachable(Expression* curr) { + if (curr->type != Type::unreachable) { + return false; + } + std::vector children; + bool hasUnreachable = false; + for (auto* child : ChildIterator(curr)) { + if (child->type.isConcrete()) { + child = builder->makeDrop(child); + } else if (child->type == Type::unreachable) { + hasUnreachable = true; + } + children.push_back(child); + } + if (!hasUnreachable) { + return false; + } + // This has an unreachable child, so we can replace it with + // the children. + auto* block = builder->makeBlock(children); + assert(block->type == Type::unreachable); + replaceCurrent(block); + return true; + } +}; + +Pass* createI64ToI32LoweringPass() { return new I64ToI32Lowering(); } + +} // namespace wasm diff --git a/binaryen/src/passes/Inlining.cpp b/binaryen/src/passes/Inlining.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/passes/Inlining.cpp @@ -0,0 +1,454 @@ +/* + * Copyright 2016 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// Inlining. +// +// This uses some simple heuristics to decide when to inline. +// +// Two versions are provided: inlining and inlining-optimizing. You +// probably want the optimizing version, which will optimize locations +// we inlined into, as inlining by itself creates a block to house the +// inlined code, some temp locals, etc., which can usually be removed +// by optimizations. Note that the two versions use the same heuristics, +// so we don't take into account the overhead if you don't optimize +// afterwards. The non-optimizing version is mainly useful for debugging, +// or if you intend to run a full set of optimizations anyhow on +// everything later. +// + +#include + +#include "ir/debug.h" +#include "ir/literal-utils.h" +#include "ir/module-utils.h" +#include "ir/utils.h" +#include "parsing.h" +#include "pass.h" +#include "passes/opt-utils.h" +#include "wasm-builder.h" +#include "wasm.h" + +namespace wasm { + +// Useful into on a function, helping us decide if we can inline it +struct FunctionInfo { + std::atomic refs; + Index size; + bool hasCalls; + bool hasLoops; + bool usedGlobally; // in a table or export + + FunctionInfo() { + refs = 0; + size = 0; + hasCalls = false; + hasLoops = false; + usedGlobally = false; + } + + // See pass.h for how defaults for these options were chosen. + bool worthInlining(PassOptions& options) { + // if it's big, it's just not worth doing (TODO: investigate more) + if (size > options.inlining.flexibleInlineMaxSize) { + return false; + } + // if it's so small we have a guarantee that after we optimize the + // size will not increase, inline it + if (size <= options.inlining.alwaysInlineMaxSize) { + return true; + } + // if it has one use, then inlining it would likely reduce code size + // since we are just moving code around, + optimizing, so worth it + // if small enough that we are pretty sure its ok + // FIXME: move this check to be first in this function, since we should + // return true if oneCallerInlineMaxSize is bigger than + // flexibleInlineMaxSize (which it typically should be). + if (refs == 1 && !usedGlobally && + size <= options.inlining.oneCallerInlineMaxSize) { + return true; + } + // More than one use, so we can't eliminate it after inlining, + // so only worth it if we really care about speed and don't care + // about size. First, check if it has calls. In that case it is not + // likely to speed us up, and also if we want to inline such + // functions we would need to be careful to avoid infinite recursion. + if (hasCalls) { + return false; + } + return options.optimizeLevel >= 3 && options.shrinkLevel == 0 && + (!hasLoops || options.inlining.allowFunctionsWithLoops); + } +}; + +typedef std::unordered_map NameInfoMap; + +struct FunctionInfoScanner + : public WalkerPass> { + bool isFunctionParallel() override { return true; } + + FunctionInfoScanner(NameInfoMap* infos) : infos(infos) {} + + FunctionInfoScanner* create() override { + return new FunctionInfoScanner(infos); + } + + void visitLoop(Loop* curr) { + // having a loop + (*infos)[getFunction()->name].hasLoops = true; + } + + void visitCall(Call* curr) { + // can't add a new element in parallel + assert(infos->count(curr->target) > 0); + (*infos)[curr->target].refs++; + // having a call + (*infos)[getFunction()->name].hasCalls = true; + } + + void visitRefFunc(RefFunc* curr) { + assert(infos->count(curr->func) > 0); + (*infos)[curr->func].refs++; + } + + void visitFunction(Function* curr) { + (*infos)[curr->name].size = Measurer::measure(curr->body); + } + +private: + NameInfoMap* infos; +}; + +struct InliningAction { + Expression** callSite; + Function* contents; + + InliningAction(Expression** callSite, Function* contents) + : callSite(callSite), contents(contents) {} +}; + +struct InliningState { + std::unordered_set worthInlining; + // function name => actions that can be performed in it + std::unordered_map> actionsForFunction; +}; + +struct Planner : public WalkerPass> { + bool isFunctionParallel() override { return true; } + + Planner(InliningState* state) : state(state) {} + + Planner* create() override { return new Planner(state); } + + void visitCall(Call* curr) { + // plan to inline if we know this is valid to inline, and if the call is + // actually performed - if it is dead code, it's pointless to inline. + // we also cannot inline ourselves. + bool isUnreachable; + if (curr->isReturn) { + // Tail calls are only actually unreachable if an argument is + isUnreachable = std::any_of( + curr->operands.begin(), curr->operands.end(), [](Expression* op) { + return op->type == Type::unreachable; + }); + } else { + isUnreachable = curr->type == Type::unreachable; + } + if (state->worthInlining.count(curr->target) && !isUnreachable && + curr->target != getFunction()->name) { + // nest the call in a block. that way the location of the pointer to the + // call will not change even if we inline multiple times into the same + // function, otherwise call1(call2()) might be a problem + auto* block = Builder(*getModule()).makeBlock(curr); + replaceCurrent(block); + // can't add a new element in parallel + assert(state->actionsForFunction.count(getFunction()->name) > 0); + state->actionsForFunction[getFunction()->name].emplace_back( + &block->list[0], getModule()->getFunction(curr->target)); + } + } + +private: + InliningState* state; +}; + +struct Updater : public PostWalker { + Module* module; + std::map localMapping; + Name returnName; + Builder* builder; + void visitReturn(Return* curr) { + replaceCurrent(builder->makeBreak(returnName, curr->value)); + } + // Return calls in inlined functions should only break out of the scope of + // the inlined code, not the entire function they are being inlined into. To + // achieve this, make the call a non-return call and add a break. This does + // not cause unbounded stack growth because inlining and return calling both + // avoid creating a new stack frame. + template void handleReturnCall(T* curr, Type targetType) { + curr->isReturn = false; + curr->type = targetType; + if (targetType.isConcrete()) { + replaceCurrent(builder->makeBreak(returnName, curr)); + } else { + replaceCurrent(builder->blockify(curr, builder->makeBreak(returnName))); + } + } + void visitCall(Call* curr) { + if (curr->isReturn) { + handleReturnCall(curr, module->getFunction(curr->target)->sig.results); + } + } + void visitCallIndirect(CallIndirect* curr) { + if (curr->isReturn) { + handleReturnCall(curr, curr->sig.results); + } + } + void visitLocalGet(LocalGet* curr) { + curr->index = localMapping[curr->index]; + } + void visitLocalSet(LocalSet* curr) { + curr->index = localMapping[curr->index]; + } +}; + +// Core inlining logic. Modifies the outside function (adding locals as +// needed), and returns the inlined code. +static Expression* +doInlining(Module* module, Function* into, const InliningAction& action) { + Function* from = action.contents; + auto* call = (*action.callSite)->cast(); + // Works for return_call, too + Type retType = module->getFunction(call->target)->sig.results; + Builder builder(*module); + auto* block = builder.makeBlock(); + block->name = Name(std::string("__inlined_func$") + from->name.str); + if (call->isReturn) { + if (retType.isConcrete()) { + *action.callSite = builder.makeReturn(block); + } else { + *action.callSite = builder.makeSequence(block, builder.makeReturn()); + } + } else { + *action.callSite = block; + } + // Prepare to update the inlined code's locals and other things. + Updater updater; + updater.module = module; + updater.returnName = block->name; + updater.builder = &builder; + // Set up a locals mapping + for (Index i = 0; i < from->getNumLocals(); i++) { + updater.localMapping[i] = builder.addVar(into, from->getLocalType(i)); + } + // Assign the operands into the params + for (Index i = 0; i < from->sig.params.size(); i++) { + block->list.push_back( + builder.makeLocalSet(updater.localMapping[i], call->operands[i])); + } + // Zero out the vars (as we may be in a loop, and may depend on their + // zero-init value + for (Index i = 0; i < from->vars.size(); i++) { + block->list.push_back( + builder.makeLocalSet(updater.localMapping[from->getVarIndexBase() + i], + LiteralUtils::makeZero(from->vars[i], *module))); + } + // Generate and update the inlined contents + auto* contents = ExpressionManipulator::copy(from->body, *module); + if (!from->debugLocations.empty()) { + debug::copyDebugInfo(from->body, contents, from, into); + } + updater.walk(contents); + block->list.push_back(contents); + block->type = retType; + // If the function returned a value, we just set the block containing the + // inlined code to have that type. or, if the function was void and + // contained void, that is fine too. a bad case is a void function in which + // we have unreachable code, so we would be replacing a void call with an + // unreachable. + if (contents->type == Type::unreachable && block->type == Type::none) { + // Make the block reachable by adding a break to it + block->list.push_back(builder.makeBreak(block->name)); + } + return block; +} + +struct Inlining : public Pass { + // whether to optimize where we inline + bool optimize = false; + + // the information for each function. recomputed in each iteraction + NameInfoMap infos; + + Index iterationNumber; + + void run(PassRunner* runner, Module* module) override { + Index numFunctions = module->functions.size(); + // keep going while we inline, to handle nesting. TODO: optimize + iterationNumber = 0; + // no point to do more iterations than the number of functions, as + // it means we infinitely recursing (which should + // be very rare in practice, but it is possible that a recursive call + // can look like it is worth inlining) + while (iterationNumber <= numFunctions) { +#ifdef INLINING_DEBUG + std::cout << "inlining loop iter " << iterationNumber + << " (numFunctions: " << numFunctions << ")\n"; +#endif + calculateInfos(module); + if (!iteration(runner, module)) { + return; + } + iterationNumber++; + } + } + + void calculateInfos(Module* module) { + infos.clear(); + // fill in info, as we operate on it in parallel (each function to its own + // entry) + for (auto& func : module->functions) { + infos[func->name]; + } + PassRunner runner(module); + FunctionInfoScanner(&infos).run(&runner, module); + // fill in global uses + // anything exported or used in a table should not be inlined + for (auto& ex : module->exports) { + if (ex->kind == ExternalKind::Function) { + infos[ex->value].usedGlobally = true; + } + } + for (auto& segment : module->table.segments) { + for (auto name : segment.data) { + infos[name].usedGlobally = true; + } + } + } + + bool iteration(PassRunner* runner, Module* module) { + // decide which to inline + InliningState state; + ModuleUtils::iterDefinedFunctions(*module, [&](Function* func) { + if (infos[func->name].worthInlining(runner->options)) { + state.worthInlining.insert(func->name); + } + }); + if (state.worthInlining.size() == 0) { + return false; + } + // fill in actionsForFunction, as we operate on it in parallel (each + // function to its own entry) + for (auto& func : module->functions) { + state.actionsForFunction[func->name]; + } + // find and plan inlinings + Planner(&state).run(runner, module); + // perform inlinings TODO: parallelize + std::unordered_map inlinedUses; // how many uses we inlined + // which functions were inlined into + std::unordered_set inlinedInto; + for (auto& func : module->functions) { + // if we've inlined a function, don't inline into it in this iteration, + // avoid risk of races + // note that we do not risk stalling progress, as each iteration() will + // inline at least one call before hitting this + if (inlinedUses.count(func->name)) { + continue; + } + for (auto& action : state.actionsForFunction[func->name]) { + auto* inlinedFunction = action.contents; + // if we've inlined into a function, don't inline it in this iteration, + // avoid risk of races + // note that we do not risk stalling progress, as each iteration() will + // inline at least one call before hitting this + if (inlinedInto.count(inlinedFunction)) { + continue; + } + Name inlinedName = inlinedFunction->name; +#ifdef INLINING_DEBUG + std::cout << "inline " << inlinedName << " into " << func->name << '\n'; +#endif + doInlining(module, func.get(), action); + inlinedUses[inlinedName]++; + inlinedInto.insert(func.get()); + assert(inlinedUses[inlinedName] <= infos[inlinedName].refs); + } + } + // anything we inlined into may now have non-unique label names, fix it up + for (auto func : inlinedInto) { + wasm::UniqueNameMapper::uniquify(func->body); + } + if (optimize && inlinedInto.size() > 0) { + OptUtils::optimizeAfterInlining(inlinedInto, module, runner); + } + // remove functions that we no longer need after inlining + module->removeFunctions([&](Function* func) { + auto name = func->name; + auto& info = infos[name]; + return inlinedUses.count(name) && inlinedUses[name] == info.refs && + !info.usedGlobally; + }); + // return whether we did any work + return inlinedUses.size() > 0; + } +}; + +Pass* createInliningPass() { return new Inlining(); } + +Pass* createInliningOptimizingPass() { + auto* ret = new Inlining(); + ret->optimize = true; + return ret; +} + +static const char* MAIN = "main"; +static const char* ORIGINAL_MAIN = "__original_main"; + +// Inline __original_main into main, if they exist. This works around the odd +// thing that clang/llvm currently do, where __original_main contains the user's +// actual main (this is done as a workaround for main having two different +// possible signatures). +struct InlineMainPass : public Pass { + void run(PassRunner* runner, Module* module) override { + auto* main = module->getFunctionOrNull(MAIN); + auto* originalMain = module->getFunctionOrNull(ORIGINAL_MAIN); + if (!main || main->imported() || !originalMain || + originalMain->imported()) { + return; + } + FindAllPointers calls(main->body); + Expression** callSite = nullptr; + for (auto* call : calls.list) { + if ((*call)->cast()->target == ORIGINAL_MAIN) { + if (callSite) { + // More than one call site. + return; + } + callSite = call; + } + } + if (!callSite) { + // No call at all. + return; + } + doInlining(module, main, InliningAction(callSite, originalMain)); + } +}; + +Pass* createInlineMainPass() { return new InlineMainPass(); } + +} // namespace wasm diff --git a/binaryen/src/passes/InstrumentLocals.cpp b/binaryen/src/passes/InstrumentLocals.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/passes/InstrumentLocals.cpp @@ -0,0 +1,253 @@ +/* + * Copyright 2017 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// Instruments the build with code to intercept all local reads and writes. +// +// gets: +// +// Before: +// (local.get $x) +// +// After: +// (call $get_TYPE +// (i32.const n) // call id +// (i32.const n) // local id +// (local.get $x) +// ) +// +// sets: +// +// Before: +// (local.set $x (i32.const 1)) +// +// After: +// (local.set $x +// (call $set_TYPE +// (i32.const n) // call id +// (i32.const n) // local id +// (i32.const 1) // value +// ) +// ) + +#include "asm_v_wasm.h" +#include "asmjs/shared-constants.h" +#include "shared-constants.h" +#include +#include +#include + +namespace wasm { + +Name get_i32("get_i32"); +Name get_i64("get_i64"); +Name get_f32("get_f32"); +Name get_f64("get_f64"); +Name get_funcref("get_funcref"); +Name get_externref("get_externref"); +Name get_exnref("get_exnref"); +Name get_anyref("get_anyref"); +Name get_eqref("get_eqref"); +Name get_i31ref("get_i31ref"); +Name get_v128("get_v128"); + +Name set_i32("set_i32"); +Name set_i64("set_i64"); +Name set_f32("set_f32"); +Name set_f64("set_f64"); +Name set_funcref("set_funcref"); +Name set_externref("set_externref"); +Name set_exnref("set_exnref"); +Name set_anyref("set_anyref"); +Name set_eqref("set_eqref"); +Name set_i31ref("set_i31ref"); +Name set_v128("set_v128"); + +struct InstrumentLocals : public WalkerPass> { + void visitLocalGet(LocalGet* curr) { + Builder builder(*getModule()); + Name import; + TODO_SINGLE_COMPOUND(curr->type); + switch (curr->type.getBasic()) { + case Type::i32: + import = get_i32; + break; + case Type::i64: + return; // TODO + case Type::f32: + import = get_f32; + break; + case Type::f64: + import = get_f64; + break; + case Type::v128: + import = get_v128; + break; + case Type::funcref: + import = get_funcref; + break; + case Type::externref: + import = get_externref; + break; + case Type::exnref: + import = get_exnref; + break; + case Type::anyref: + import = get_anyref; + break; + case Type::eqref: + import = get_eqref; + break; + case Type::i31ref: + import = get_i31ref; + break; + case Type::none: + case Type::unreachable: + WASM_UNREACHABLE("unexpected type"); + } + replaceCurrent(builder.makeCall(import, + {builder.makeConst(int32_t(id++)), + builder.makeConst(int32_t(curr->index)), + curr}, + curr->type)); + } + + void visitLocalSet(LocalSet* curr) { + // We don't instrument pop instructions. They are automatically deleted when + // writing binary and generated when reading binary, so they don't work with + // local set/get instrumentation. + if (curr->value->is()) { + return; + } + + Builder builder(*getModule()); + Name import; + TODO_SINGLE_COMPOUND(curr->value->type); + switch (curr->value->type.getBasic()) { + case Type::i32: + import = set_i32; + break; + case Type::i64: + return; // TODO + case Type::f32: + import = set_f32; + break; + case Type::f64: + import = set_f64; + break; + case Type::v128: + import = set_v128; + break; + case Type::funcref: + import = set_funcref; + break; + case Type::externref: + import = set_externref; + break; + case Type::exnref: + import = set_exnref; + break; + case Type::anyref: + import = set_anyref; + break; + case Type::eqref: + import = set_eqref; + break; + case Type::i31ref: + import = set_i31ref; + break; + case Type::unreachable: + return; // nothing to do here + case Type::none: + WASM_UNREACHABLE("unexpected type"); + } + curr->value = builder.makeCall(import, + {builder.makeConst(int32_t(id++)), + builder.makeConst(int32_t(curr->index)), + curr->value}, + curr->value->type); + } + + void visitModule(Module* curr) { + addImport(curr, get_i32, {Type::i32, Type::i32, Type::i32}, Type::i32); + addImport(curr, get_i64, {Type::i32, Type::i32, Type::i64}, Type::i64); + addImport(curr, get_f32, {Type::i32, Type::i32, Type::f32}, Type::f32); + addImport(curr, get_f64, {Type::i32, Type::i32, Type::f64}, Type::f64); + addImport(curr, set_i32, {Type::i32, Type::i32, Type::i32}, Type::i32); + addImport(curr, set_i64, {Type::i32, Type::i32, Type::i64}, Type::i64); + addImport(curr, set_f32, {Type::i32, Type::i32, Type::f32}, Type::f32); + addImport(curr, set_f64, {Type::i32, Type::i32, Type::f64}, Type::f64); + + if (curr->features.hasReferenceTypes()) { + addImport(curr, + get_funcref, + {Type::i32, Type::i32, Type::funcref}, + Type::funcref); + addImport(curr, + set_funcref, + {Type::i32, Type::i32, Type::funcref}, + Type::funcref); + addImport(curr, + get_externref, + {Type::i32, Type::i32, Type::externref}, + Type::externref); + addImport(curr, + set_externref, + {Type::i32, Type::i32, Type::externref}, + Type::externref); + if (curr->features.hasExceptionHandling()) { + addImport( + curr, get_exnref, {Type::i32, Type::i32, Type::exnref}, Type::exnref); + addImport( + curr, set_exnref, {Type::i32, Type::i32, Type::exnref}, Type::exnref); + } + if (curr->features.hasGC()) { + addImport( + curr, get_anyref, {Type::i32, Type::i32, Type::anyref}, Type::anyref); + addImport( + curr, set_anyref, {Type::i32, Type::i32, Type::anyref}, Type::anyref); + addImport( + curr, get_eqref, {Type::i32, Type::i32, Type::eqref}, Type::eqref); + addImport( + curr, set_eqref, {Type::i32, Type::i32, Type::eqref}, Type::eqref); + addImport( + curr, get_i31ref, {Type::i32, Type::i32, Type::i31ref}, Type::i31ref); + addImport( + curr, set_i31ref, {Type::i32, Type::i32, Type::i31ref}, Type::i31ref); + } + } + if (curr->features.hasSIMD()) { + addImport(curr, get_v128, {Type::i32, Type::i32, Type::v128}, Type::v128); + addImport(curr, set_v128, {Type::i32, Type::i32, Type::v128}, Type::v128); + } + } + +private: + Index id = 0; + + void addImport(Module* wasm, Name name, Type params, Type results) { + auto import = new Function; + import->name = name; + import->module = ENV; + import->base = name; + import->sig = Signature(params, results); + wasm->addFunction(import); + } +}; + +Pass* createInstrumentLocalsPass() { return new InstrumentLocals(); } + +} // namespace wasm diff --git a/binaryen/src/passes/InstrumentMemory.cpp b/binaryen/src/passes/InstrumentMemory.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/passes/InstrumentMemory.cpp @@ -0,0 +1,173 @@ +/* + * Copyright 2017 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// Instruments the build with code to intercept all memory reads and writes. +// This can be useful in building tools that analyze memory access behaviour. +// +// Before: +// (i32.load8_s align=1 offset=2 (i32.const 3)) +// +// After: +// (call $load_val_i32 +// (i32.const n) // ID +// (i32.load8_s align=1 offset=2 +// (call $load_ptr +// (i32.const n) // ID +// (i32.const 1) // bytes +// (i32.const 2) // offset +// (i32.const 3) // address +// ) +// ) +// ) +// Stores: store(id, bytes, offset, address) => address +// +// Before: +// (i32.store8 align=1 offset=2 (i32.const 3) (i32.const 4)) +// +// After: +// (i32.store16 align=1 offset=2 +// (call $store_ptr +// (i32.const n) // ID +// (i32.const 1) // bytes +// (i32.const 2) // offset +// (i32.const 3) // address +// ) +// (call $store_val_i32 +// (i32.const n) // ID +// (i32.const 4) +// ) +// ) + +#include "asm_v_wasm.h" +#include "asmjs/shared-constants.h" +#include "shared-constants.h" +#include +#include +#include + +namespace wasm { + +static Name load_ptr("load_ptr"); +static Name load_val_i32("load_val_i32"); +static Name load_val_i64("load_val_i64"); +static Name load_val_f32("load_val_f32"); +static Name load_val_f64("load_val_f64"); +static Name store_ptr("store_ptr"); +static Name store_val_i32("store_val_i32"); +static Name store_val_i64("store_val_i64"); +static Name store_val_f32("store_val_f32"); +static Name store_val_f64("store_val_f64"); + +// TODO: Add support for atomicRMW/cmpxchg + +struct InstrumentMemory : public WalkerPass> { + void visitLoad(Load* curr) { + id++; + Builder builder(*getModule()); + auto indexType = getModule()->memory.indexType; + auto offset = builder.makeConstPtr(curr->offset.addr); + curr->ptr = builder.makeCall(load_ptr, + {builder.makeConst(int32_t(id)), + builder.makeConst(int32_t(curr->bytes)), + offset, + curr->ptr}, + indexType); + Name target; + switch (curr->type.getBasic()) { + case Type::i32: + target = load_val_i32; + break; + case Type::i64: + target = load_val_i64; + break; + case Type::f32: + target = load_val_f32; + break; + case Type::f64: + target = load_val_f64; + break; + default: + return; // TODO: other types, unreachable, etc. + } + replaceCurrent(builder.makeCall( + target, {builder.makeConst(int32_t(id)), curr}, curr->type)); + } + + void visitStore(Store* curr) { + id++; + Builder builder(*getModule()); + auto indexType = getModule()->memory.indexType; + auto offset = builder.makeConstPtr(curr->offset.addr); + curr->ptr = builder.makeCall(store_ptr, + {builder.makeConst(int32_t(id)), + builder.makeConst(int32_t(curr->bytes)), + offset, + curr->ptr}, + indexType); + Name target; + switch (curr->value->type.getBasic()) { + case Type::i32: + target = store_val_i32; + break; + case Type::i64: + target = store_val_i64; + break; + case Type::f32: + target = store_val_f32; + break; + case Type::f64: + target = store_val_f64; + break; + default: + return; // TODO: other types, unreachable, etc. + } + curr->value = builder.makeCall( + target, {builder.makeConst(int32_t(id)), curr->value}, curr->value->type); + } + + void visitModule(Module* curr) { + auto indexType = curr->memory.indexType; + addImport( + curr, load_ptr, {Type::i32, Type::i32, indexType, indexType}, indexType); + addImport(curr, load_val_i32, {Type::i32, Type::i32}, Type::i32); + addImport(curr, load_val_i64, {Type::i32, Type::i64}, Type::i64); + addImport(curr, load_val_f32, {Type::i32, Type::f32}, Type::f32); + addImport(curr, load_val_f64, {Type::i32, Type::f64}, Type::f64); + addImport( + curr, store_ptr, {Type::i32, Type::i32, indexType, indexType}, indexType); + addImport(curr, store_val_i32, {Type::i32, Type::i32}, Type::i32); + addImport(curr, store_val_i64, {Type::i32, Type::i64}, Type::i64); + addImport(curr, store_val_f32, {Type::i32, Type::f32}, Type::f32); + addImport(curr, store_val_f64, {Type::i32, Type::f64}, Type::f64); + } + +private: + Index id; + + void addImport(Module* curr, Name name, Type params, Type results) { + auto import = new Function; + import->name = name; + import->module = ENV; + import->base = name; + import->sig = Signature(params, results); + curr->addFunction(import); + } +}; + +Pass* createInstrumentMemoryPass() { return new InstrumentMemory(); } + +} // namespace wasm diff --git a/binaryen/src/passes/LegalizeJSInterface.cpp b/binaryen/src/passes/LegalizeJSInterface.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/passes/LegalizeJSInterface.cpp @@ -0,0 +1,347 @@ +/* + * Copyright 2016 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// i64 values are not valid in JS, and must be handled in some other +// way. This pass transforms all i64s in params and results in imports +// and exports into pairs of i32, i32 (low, high). If JS on the outside +// calls with that ABI, then everything should then just work, using +// stub methods added in this pass, that thunk i64s into i32, i32 and +// vice versa as necessary. +// +// We can also legalize in a "minimal" way, that is, only JS-specific +// components, that only JS will care about, such as dynCall methods +// (wasm will never call them, as it can share the table directly). E.g. +// is dynamic linking, where we can avoid legalizing wasm=>wasm calls +// across modules, we still want to legalize dynCalls so JS can call into the +// table even to a signature that is not legal. +// + +#include "asm_v_wasm.h" +#include "asmjs/shared-constants.h" +#include "ir/import-utils.h" +#include "ir/literal-utils.h" +#include "ir/utils.h" +#include "pass.h" +#include "shared-constants.h" +#include "wasm-builder.h" +#include "wasm.h" +#include + +namespace wasm { + +struct LegalizeJSInterface : public Pass { + bool full; + + LegalizeJSInterface(bool full) : full(full) {} + + void run(PassRunner* runner, Module* module) override { + auto exportOriginals = + !runner->options + .getArgumentOrDefault("legalize-js-interface-export-originals", "") + .empty(); + // for each illegal export, we must export a legalized stub instead + std::vector newExports; + for (auto& ex : module->exports) { + if (ex->kind == ExternalKind::Function) { + // if it's an import, ignore it + auto* func = module->getFunction(ex->value); + if (isIllegal(func) && shouldBeLegalized(ex.get(), func)) { + // Provide a legal function for the export. + auto legalName = makeLegalStub(func, module); + ex->value = legalName; + if (exportOriginals) { + // Also export the original function, before legalization. This is + // not normally useful for JS, except in cases like dynamic linking + // where the JS loader code must copy exported wasm functions into + // the table, and they must not be legalized as other wasm code will + // do an indirect call to them. However, don't do this for imported + // functions, as those would be legalized in their actual module + // anyhow. It also makes no sense to do this for dynCalls, as they + // are only called from JS. + if (!func->imported() && !isDynCall(ex->name)) { + Builder builder(*module); + Name newName = std::string("orig$") + ex->name.str; + newExports.push_back(builder.makeExport( + newName, func->name, ExternalKind::Function)); + } + } + } + } + } + for (auto* ex : newExports) { + module->addExport(ex); + } + // Avoid iterator invalidation later. + std::vector originalFunctions; + for (auto& func : module->functions) { + originalFunctions.push_back(func.get()); + } + // for each illegal import, we must call a legalized stub instead + for (auto* im : originalFunctions) { + if (im->imported() && isIllegal(im) && shouldBeLegalized(im)) { + auto funcName = makeLegalStubForCalledImport(im, module); + illegalImportsToLegal[im->name] = funcName; + // we need to use the legalized version in the table, as the import from + // JS is legal for JS. Our stub makes it look like a native wasm + // function. + for (auto& segment : module->table.segments) { + for (auto& name : segment.data) { + if (name == im->name) { + name = funcName; + } + } + } + } + } + + if (!illegalImportsToLegal.empty()) { + // Gather functions used in 'ref.func'. They should not be removed. + std::unordered_map> usedInRefFunc; + + // Fill in unordered_map, as we operate on it in parallel. + for (auto& func : module->functions) { + usedInRefFunc[func->name]; + } + + struct RefFuncScanner : public WalkerPass> { + Module& wasm; + std::unordered_map>& usedInRefFunc; + + bool isFunctionParallel() override { return true; } + + Pass* create() override { + return new RefFuncScanner(wasm, usedInRefFunc); + } + + RefFuncScanner( + Module& wasm, + std::unordered_map>& usedInRefFunc) + : wasm(wasm), usedInRefFunc(usedInRefFunc) {} + + void visitRefFunc(RefFunc* curr) { usedInRefFunc[curr->func] = true; } + }; + + RefFuncScanner(*module, usedInRefFunc).run(runner, module); + for (auto& pair : illegalImportsToLegal) { + if (!usedInRefFunc[pair.first]) { + module->removeFunction(pair.first); + } + } + + // fix up imports: call_import of an illegal must be turned to a call of a + // legal + struct FixImports : public WalkerPass> { + bool isFunctionParallel() override { return true; } + + Pass* create() override { + return new FixImports(illegalImportsToLegal); + } + + std::map* illegalImportsToLegal; + + FixImports(std::map* illegalImportsToLegal) + : illegalImportsToLegal(illegalImportsToLegal) {} + + void visitCall(Call* curr) { + auto iter = illegalImportsToLegal->find(curr->target); + if (iter == illegalImportsToLegal->end()) { + return; + } + + if (iter->second == getFunction()->name) { + // inside the stub function itself, is the one safe place to do the + // call + return; + } + replaceCurrent( + Builder(*getModule()) + .makeCall( + iter->second, curr->operands, curr->type, curr->isReturn)); + } + }; + + FixImports(&illegalImportsToLegal).run(runner, module); + } + } + +private: + // map of illegal to legal names for imports + std::map illegalImportsToLegal; + + template bool isIllegal(T* t) { + for (const auto& param : t->sig.params) { + if (param == Type::i64) { + return true; + } + } + return t->sig.results == Type::i64; + } + + bool isDynCall(Name name) { return name.startsWith("dynCall_"); } + + // Check if an export should be legalized. + bool shouldBeLegalized(Export* ex, Function* func) { + if (full) { + return true; + } + // We are doing minimal legalization - just what JS needs. + return isDynCall(ex->name); + } + + // Check if an import should be legalized. + bool shouldBeLegalized(Function* im) { + if (full) { + return true; + } + // We are doing minimal legalization - just what JS needs. + return im->module == ENV && im->base.startsWith("invoke_"); + } + + // JS calls the export, so it must call a legal stub that calls the actual + // wasm function + Name makeLegalStub(Function* func, Module* module) { + Name legalName(std::string("legalstub$") + func->name.str); + + // a method may be exported multiple times + if (module->getFunctionOrNull(legalName)) { + return legalName; + } + + Builder builder(*module); + auto* legal = new Function(); + legal->name = legalName; + + auto* call = module->allocator.alloc(); + call->target = func->name; + call->type = func->sig.results; + + std::vector legalParams; + for (const auto& param : func->sig.params) { + if (param == Type::i64) { + call->operands.push_back(I64Utilities::recreateI64( + builder, legalParams.size(), legalParams.size() + 1)); + legalParams.push_back(Type::i32); + legalParams.push_back(Type::i32); + } else { + call->operands.push_back( + builder.makeLocalGet(legalParams.size(), param)); + legalParams.push_back(param); + } + } + legal->sig.params = Type(legalParams); + + if (func->sig.results == Type::i64) { + Function* f = + getFunctionOrImport(module, SET_TEMP_RET0, Type::i32, Type::none); + legal->sig.results = Type::i32; + auto index = Builder::addVar(legal, Name(), Type::i64); + auto* block = builder.makeBlock(); + block->list.push_back(builder.makeLocalSet(index, call)); + block->list.push_back(builder.makeCall( + f->name, {I64Utilities::getI64High(builder, index)}, Type::none)); + block->list.push_back(I64Utilities::getI64Low(builder, index)); + block->finalize(); + legal->body = block; + } else { + legal->sig.results = func->sig.results; + legal->body = call; + } + + return module->addFunction(legal)->name; + } + + // wasm calls the import, so it must call a stub that calls the actual legal + // JS import + Name makeLegalStubForCalledImport(Function* im, Module* module) { + Builder builder(*module); + auto legalIm = make_unique(); + legalIm->name = Name(std::string("legalimport$") + im->name.str); + legalIm->module = im->module; + legalIm->base = im->base; + auto stub = make_unique(); + stub->name = Name(std::string("legalfunc$") + im->name.str); + stub->sig = im->sig; + + auto* call = module->allocator.alloc(); + call->target = legalIm->name; + + std::vector params; + Index i = 0; + for (const auto& param : im->sig.params) { + if (param == Type::i64) { + call->operands.push_back(I64Utilities::getI64Low(builder, i)); + call->operands.push_back(I64Utilities::getI64High(builder, i)); + params.push_back(Type::i32); + params.push_back(Type::i32); + } else { + call->operands.push_back(builder.makeLocalGet(i, param)); + params.push_back(param); + } + ++i; + } + + if (im->sig.results == Type::i64) { + Function* f = + getFunctionOrImport(module, GET_TEMP_RET0, Type::none, Type::i32); + call->type = Type::i32; + Expression* get = builder.makeCall(f->name, {}, call->type); + stub->body = I64Utilities::recreateI64(builder, call, get); + } else { + call->type = im->sig.results; + stub->body = call; + } + legalIm->sig = Signature(Type(params), call->type); + + const auto& stubName = stub->name; + if (!module->getFunctionOrNull(stubName)) { + module->addFunction(std::move(stub)); + } + if (!module->getFunctionOrNull(legalIm->name)) { + module->addFunction(std::move(legalIm)); + } + return stubName; + } + + static Function* + getFunctionOrImport(Module* module, Name name, Type params, Type results) { + // First look for the function by name + if (Function* f = module->getFunctionOrNull(name)) { + return f; + } + // Then see if its already imported + ImportInfo info(*module); + if (Function* f = info.getImportedFunction(ENV, name)) { + return f; + } + // Failing that create a new function import. + auto import = new Function; + import->name = name; + import->module = ENV; + import->base = name; + import->sig = Signature(params, results); + module->addFunction(import); + return import; + } +}; + +Pass* createLegalizeJSInterfacePass() { return new LegalizeJSInterface(true); } + +Pass* createLegalizeJSInterfaceMinimallyPass() { + return new LegalizeJSInterface(false); +} + +} // namespace wasm diff --git a/binaryen/src/passes/LimitSegments.cpp b/binaryen/src/passes/LimitSegments.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/passes/LimitSegments.cpp @@ -0,0 +1,36 @@ +/* + * Copyright 2019 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "ir/memory-utils.h" +#include "pass.h" +#include "wasm.h" + +using namespace std; + +namespace wasm { + +struct LimitSegments : public Pass { + void run(PassRunner* runner, Module* module) override { + if (!MemoryUtils::ensureLimitedSegments(*module)) { + std::cerr << "Unable to merge segments. " + << "wasm VMs may not accept this binary" << std::endl; + } + } +}; + +Pass* createLimitSegmentsPass() { return new LimitSegments(); } + +} // namespace wasm diff --git a/binaryen/src/passes/LocalCSE.cpp b/binaryen/src/passes/LocalCSE.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/passes/LocalCSE.cpp @@ -0,0 +1,271 @@ +/* + * Copyright 2017 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// Local CSE +// +// This requires --flatten to be run before in order to be effective, +// and preserves flatness. The reason flatness is required is that +// this pass assumes everything is stored in a local, and all it does +// is alter local.sets to do local.gets of an existing value when +// possible, replacing a recomputing of that value. That design means that +// if there are block and if return values, nested expressions not stored +// to a local, etc., then it can't operate on them (and will just not +// do anything for them). +// +// In each linear area of execution, +// * track each relevant (big enough) expression +// * if already seen, write to a local if not already, and reuse +// * invalidate the list as we see effects +// +// TODO: global, inter-block gvn etc. +// + +#include +#include + +#include "ir/flat.h" +#include +#include +#include +#include +#include +#include +#include +#include + +namespace wasm { + +struct LocalCSE : public WalkerPass> { + bool isFunctionParallel() override { return true; } + + Pass* create() override { return new LocalCSE(); } + + struct Usable { + HashedExpression hashed; + Type localType; + Usable(HashedExpression hashed, Type localType) + : hashed(hashed), localType(localType) {} + }; + + struct UsableHasher { + size_t operator()(const Usable value) const { + auto digest = value.hashed.digest; + wasm::rehash(digest, value.localType.getID()); + return digest; + } + }; + + struct UsableComparer { + bool operator()(const Usable a, const Usable b) const { + if (a.hashed.digest != b.hashed.digest || a.localType != b.localType) { + return false; + } + return ExpressionAnalyzer::equal(a.hashed.expr, b.hashed.expr); + } + }; + + // information for an expression we can reuse + struct UsableInfo { + Expression* value; // the value we can reuse + Index index; // the local we are assigned to, local.get that to reuse us + EffectAnalyzer effects; + + UsableInfo(Expression* value, + Index index, + PassOptions& passOptions, + FeatureSet features) + : value(value), index(index), effects(passOptions, features, value) {} + }; + + // a list of usables in a linear execution trace + class Usables + : public std:: + unordered_map {}; + + // locals in current linear execution trace, which we try to sink + Usables usables; + + // We track locals containing the same value - the value is what matters, not + // the index. + EquivalentSets equivalences; + + bool anotherPass; + + void doWalkFunction(Function* func) { + Flat::verifyFlatness(func); + anotherPass = true; + // we may need multiple rounds + while (anotherPass) { + anotherPass = false; + clear(); + super::doWalkFunction(func); + } + } + + static void doNoteNonLinear(LocalCSE* self, Expression** currp) { + self->clear(); + } + + void clear() { + usables.clear(); + equivalences.clear(); + } + + // Checks invalidations due to a set of effects. Also optionally receive + // an expression that was just post-visited, and that also needs to be + // taken into account. + void checkInvalidations(EffectAnalyzer& effects, Expression* curr = nullptr) { + // TODO: this is O(bad) + std::vector invalidated; + for (auto& sinkable : usables) { + // Check invalidations of the values we may want to use. + if (effects.invalidates(sinkable.second.effects)) { + invalidated.push_back(sinkable.first); + } + } + if (curr) { + // If we are a set, we have more to check: each of the usable + // values was from a set, and we did not consider the set in + // the loop above - just the values. So here we must check that + // sets do not interfere. (Note that due to flattening we + // have no risk of tees etc.) + if (auto* set = curr->dynCast()) { + for (auto& sinkable : usables) { + // Check if the index is the same. Make sure to ignore + // our own value, which we may have just added! + if (sinkable.second.index == set->index && + sinkable.second.value != set->value) { + invalidated.push_back(sinkable.first); + } + } + } + } + for (auto index : invalidated) { + usables.erase(index); + } + } + + std::vector expressionStack; + + static void visitPre(LocalCSE* self, Expression** currp) { + // pre operations + Expression* curr = *currp; + + EffectAnalyzer effects(self->getPassOptions(), self->getModule()->features); + if (effects.checkPre(curr)) { + self->checkInvalidations(effects); + } + + self->expressionStack.push_back(curr); + } + + static void visitPost(LocalCSE* self, Expression** currp) { + auto* curr = *currp; + + // main operations + self->handle(curr); + + // post operations + + EffectAnalyzer effects(self->getPassOptions(), self->getModule()->features); + if (effects.checkPost(curr)) { + self->checkInvalidations(effects, curr); + } + + self->expressionStack.pop_back(); + } + + // override scan to add a pre and a post check task to all nodes + static void scan(LocalCSE* self, Expression** currp) { + self->pushTask(visitPost, currp); + + super::scan(self, currp); + + self->pushTask(visitPre, currp); + } + + void handle(Expression* curr) { + if (auto* set = curr->dynCast()) { + // Calculate equivalences + auto* func = getFunction(); + equivalences.reset(set->index); + if (auto* get = set->value->dynCast()) { + if (func->getLocalType(set->index) == func->getLocalType(get->index)) { + equivalences.add(set->index, get->index); + } + } + // consider the value + auto* value = set->value; + if (isRelevant(value)) { + Usable usable(value, func->getLocalType(set->index)); + auto iter = usables.find(usable); + if (iter != usables.end()) { + // already exists in the table, this is good to reuse + auto& info = iter->second; + Type localType = func->getLocalType(info.index); + set->value = + Builder(*getModule()).makeLocalGet(info.index, localType); + anotherPass = true; + } else { + // not in table, add this, maybe we can help others later + usables.emplace(std::make_pair( + usable, + UsableInfo( + value, set->index, getPassOptions(), getModule()->features))); + } + } + } else if (auto* get = curr->dynCast()) { + if (auto* set = equivalences.getEquivalents(get->index)) { + // Canonicalize to the lowest index. This lets hashing and comparisons + // "just work". + get->index = *std::min_element(set->begin(), set->end()); + } + } + } + + // A relevant value is a non-trivial one, something we may want to reuse + // and are able to. + bool isRelevant(Expression* value) { + if (value->is()) { + return false; // trivial, this is what we optimize to! + } + if (!value->type.isConcrete()) { + return false; // don't bother with unreachable etc. + } + if (EffectAnalyzer(getPassOptions(), getModule()->features, value) + .hasSideEffects()) { + return false; // we can't combine things with side effects + } + auto& options = getPassRunner()->options; + // If the size is at least 3, then if we have two of them we have 6, + // and so adding one set+two gets and removing one of the items itself + // is not detrimental, and may be beneficial. + if (options.shrinkLevel > 0 && Measurer::measure(value) >= 3) { + return true; + } + // If we focus on speed, any reduction in cost is beneficial, as the + // cost of a get is essentially free. + if (options.shrinkLevel == 0 && CostAnalyzer(value).cost > 0) { + return true; + } + return false; + } +}; + +Pass* createLocalCSEPass() { return new LocalCSE(); } + +} // namespace wasm diff --git a/binaryen/src/passes/LogExecution.cpp b/binaryen/src/passes/LogExecution.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/passes/LogExecution.cpp @@ -0,0 +1,81 @@ +/* + * Copyright 2017 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// Instruments the build with code to log execution at each function +// entry, loop header, and return. This can be useful in debugging, to log out +// a trace, and diff it to another (running in another browser, to +// check for bugs, for example). +// +// The logging is performed by calling an ffi with an id for each +// call site. You need to provide that import on the JS side. +// +// This pass is more effective on flat IR (--flatten) since when it +// instruments say a return, there will be no code run in the return's +// value. +// + +#include "asm_v_wasm.h" +#include "asmjs/shared-constants.h" +#include "shared-constants.h" +#include +#include +#include + +namespace wasm { + +Name LOGGER("log_execution"); + +struct LogExecution : public WalkerPass> { + void visitLoop(Loop* curr) { curr->body = makeLogCall(curr->body); } + + void visitReturn(Return* curr) { replaceCurrent(makeLogCall(curr)); } + + void visitFunction(Function* curr) { + if (curr->imported()) { + return; + } + if (auto* block = curr->body->dynCast()) { + if (!block->list.empty()) { + block->list.back() = makeLogCall(block->list.back()); + } + } + curr->body = makeLogCall(curr->body); + } + + void visitModule(Module* curr) { + // Add the import + auto import = new Function; + import->name = LOGGER; + import->module = ENV; + import->base = LOGGER; + import->sig = Signature(Type::i32, Type::none); + curr->addFunction(import); + } + +private: + Expression* makeLogCall(Expression* curr) { + static Index id = 0; + Builder builder(*getModule()); + return builder.makeSequence( + builder.makeCall(LOGGER, {builder.makeConst(int32_t(id++))}, Type::none), + curr); + } +}; + +Pass* createLogExecutionPass() { return new LogExecution(); } + +} // namespace wasm diff --git a/binaryen/src/passes/LoopInvariantCodeMotion.cpp b/binaryen/src/passes/LoopInvariantCodeMotion.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/passes/LoopInvariantCodeMotion.cpp @@ -0,0 +1,252 @@ +/* + * Copyright 2018 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// Simple loop invariant code motion (licm): for every none-typed +// expression in a loop, see if we can move it out. +// +// Flattening is not necessary here, but may help (as separating +// out expressions may allow moving at least part of a larger whole). +// + +#include + +#include "ir/effects.h" +#include "ir/find_all.h" +#include "ir/local-graph.h" +#include "pass.h" +#include "wasm-builder.h" +#include "wasm.h" + +namespace wasm { + +struct LoopInvariantCodeMotion + : public WalkerPass> { + bool isFunctionParallel() override { return true; } + + Pass* create() override { return new LoopInvariantCodeMotion; } + + typedef std::unordered_set LoopSets; + + // main entry point + + LocalGraph* localGraph; + + void doWalkFunction(Function* func) { + // Compute all local dependencies first. + LocalGraph localGraphInstance(func); + localGraph = &localGraphInstance; + // Traverse the function. + super::doWalkFunction(func); + } + + void visitLoop(Loop* loop) { + // We accumulate all the code we can move out, and will place it + // in a block just preceding the loop. + std::vector movedCode; + // Accumulate effects of things we can't move out - things + // we move out later must cross them, so we must verify it + // is ok to do so. + FeatureSet features = getModule()->features; + EffectAnalyzer effectsSoFar(getPassOptions(), features); + // The loop's total effects also matter. For example, a store + // in the loop means we can't move a load outside. + // FIXME: we look at the loop "tail" area too, after the last + // possible branch back, which can cause false positives + // for bad effect interactions. + EffectAnalyzer loopEffects(getPassOptions(), features, loop); + // Note all the sets in each loop, and how many per index. Currently + // EffectAnalyzer can't do that, and we need it to know if we + // can move a set out of the loop (if there is another set + // still there, we can't). Another possible option here is for + // LocalGraph to track interfering sets. TODO + // FIXME: also the loop tail issue from above. + auto numLocals = getFunction()->getNumLocals(); + std::vector numSetsForIndex(numLocals); + std::fill(numSetsForIndex.begin(), numSetsForIndex.end(), 0); + LoopSets loopSets; + { + FindAll finder(loop); + for (auto* set : finder.list) { + numSetsForIndex[set->index]++; + loopSets.insert(set); + } + } + // Walk along the loop entrance, while all the code there + // is executed unconditionally. That is the code we want to + // move out - anything that might or might not be executed + // may be best left alone anyhow. + std::vector work; + work.push_back(&loop->body); + while (!work.empty()) { + auto** currp = work.back(); + work.pop_back(); + auto* curr = *currp; + // Look into blocks. + if (auto* block = curr->dynCast()) { + auto& list = block->list; + Index i = list.size(); + while (i > 0) { + i--; + work.push_back(&list[i]); + } + continue; + // Note that if the block had a merge at the end, we would have seen + // a branch to it anyhow, so we would stop before that point anyhow. + } + // If this may branch, we are done. + EffectAnalyzer effects(getPassOptions(), features, curr); + if (effects.transfersControlFlow()) { + break; + } + if (interestingToMove(curr)) { + // Let's see if we can move this out. + // Global side effects would prevent this - we might end up + // executing them just once. + // And we must also move across anything not moved out already, + // so check for issues there too. + // The rest of the loop's effects matter too, we must also + // take into account global state like interacting loads and + // stores. + bool unsafeToMove = effects.hasGlobalSideEffects() || + effectsSoFar.invalidates(effects) || + (effects.noticesGlobalSideEffects() && + loopEffects.hasGlobalSideEffects()); + if (!unsafeToMove) { + // So far so good. Check if our local dependencies are all + // outside of the loop, in which case everything is good - + // either they are before the loop and constant for us, or + // they are after and don't matter. + if (effects.localsRead.empty() || + !hasGetDependingOnLoopSet(curr, loopSets)) { + // We have checked if our gets are influenced by sets in the loop, + // and must also check if our sets interfere with them. To do so, + // assume temporarily that we are moving curr out; see if any sets + // remain for its indexes. + FindAll currSets(curr); + for (auto* set : currSets.list) { + assert(numSetsForIndex[set->index] > 0); + numSetsForIndex[set->index]--; + } + bool canMove = true; + for (auto* set : currSets.list) { + if (numSetsForIndex[set->index] > 0) { + canMove = false; + break; + } + } + if (!canMove) { + // We failed to move the code, undo those changes. + for (auto* set : currSets.list) { + numSetsForIndex[set->index]++; + } + } else { + // We can move it! Leave the changes, move the code, and update + // loopSets. + movedCode.push_back(curr); + *currp = Builder(*getModule()).makeNop(); + for (auto* set : currSets.list) { + loopSets.erase(set); + } + continue; + } + } + } + } + // We did not move this item. Accumulate its effects. + effectsSoFar.mergeIn(effects); + } + // If we moved the code out, finish up by emitting it + // outside of the loop. + // Note that this works with nested loops - after moving outside + // of an inner loop, we can encounter it again in an outer loop, + // and move it further outside, without requiring any extra pass. + if (!movedCode.empty()) { + // Finish the moving by emitting the code outside. + Builder builder(*getModule()); + auto* ret = builder.makeBlock(movedCode); + ret->list.push_back(loop); + ret->finalize(loop->type); + replaceCurrent(ret); + // Note that we do not need to modify the localGraph - we keep + // each get in a position to be influenced by exactly the same + // sets as before. + } + } + + bool interestingToMove(Expression* curr) { + // In theory we could consider blocks, but then heavy nesting of + // switch patterns would be heavy, and almost always pointless. + if (curr->type != Type::none || curr->is() || curr->is() || + curr->is()) { + return false; + } + // Don't move copies (set of a get, or set of a tee of a get, etc.), + // as they often do not turn into actual work inside the loop + // (after later optimizations by us or the VM), and if we move them + // out it will prevent other opts from potentially eliminating the + // copy, as we don't have another pass that considers moving code + // back *into* loops. + // Likewise, constants also are not worth moving out. + // Note that the issue remains for moving things out which later + // optimizations turn into a copy or a constant, so in general + // it is beneficial to run this pass later on (but that has downsides + // too, as with more nesting moving code is harder - so something + // like -O --flatten --licm -O may be best). + if (auto* set = curr->dynCast()) { + while (1) { + auto* next = set->value->dynCast(); + if (!next) { + break; + } + set = next; + } + if (set->value->is() || set->value->is()) { + return false; + } + } + return true; + } + + bool hasGetDependingOnLoopSet(Expression* curr, LoopSets& loopSets) { + FindAll gets(curr); + for (auto* get : gets.list) { + auto& sets = localGraph->getSetses[get]; + for (auto* set : sets) { + // nullptr means a parameter or zero-init value; + // no danger to us. + if (!set) { + continue; + } + // Check if the set is in the loop. If not, it's either before, + // which is fine, or after, which is also fine - moving curr + // to just outside the loop will preserve those relationships. + // TODO: this still counts curr's sets as inside the loop, which + // might matter in non-flat mode. + if (loopSets.count(set)) { + return true; + } + } + } + return false; + } +}; + +Pass* createLoopInvariantCodeMotionPass() { + return new LoopInvariantCodeMotion(); +} + +} // namespace wasm diff --git a/binaryen/src/passes/MemoryPacking.cpp b/binaryen/src/passes/MemoryPacking.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/passes/MemoryPacking.cpp @@ -0,0 +1,678 @@ +/* + * Copyright 2016 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// Memory Packing. +// +// Reduces binary size by splitting data segments around ranges of zeros. This +// pass assumes that memory initialized by active segments is zero on +// instantiation and therefore simply drops the zero ranges from the active +// segments. For passive segments, we perform the same splitting, but we also +// record how each segment was split and update all bulk memory operations +// accordingly. To preserve trapping semantics for memory.init instructions, it +// is sometimes necessary to explicitly track whether input segments would have +// been dropped in globals. We are careful to emit only as many of these globals +// as necessary. +// + +#include "ir/manipulation.h" +#include "ir/module-utils.h" +#include "ir/utils.h" +#include "pass.h" +#include "wasm-binary.h" +#include "wasm-builder.h" +#include "wasm.h" + +namespace wasm { + +// A subsection of an orginal memory segment. If `isZero` is true, memory.fill +// will be used instead of memory.init for this range. +struct Range { + bool isZero; + size_t start; + size_t end; +}; + +// A function that produces the transformed bulk memory op. We need to use a +// function here instead of simple data because the replacement code sequence +// may require allocating new locals, which in turn requires the enclosing +// Function, which is only available in the parallelized instruction replacement +// phase. However, we can't move the entire calculation of replacement code +// sequences into the parallel phase because the lowering of data.drops depends +// on the lowering of memory.inits to determine whether a drop state global is +// necessary. The solution is that we calculate the shape of the replacement +// code sequence up front and use a closure just to allocate and insert new +// locals as necessary. +using Replacement = std::function; + +// Maps each bulk memory op to the replacement that must be applied to it. +using Replacements = std::unordered_map; + +// A collection of bulk memory operations referring to a particular segment +using Referrers = std::vector; + +// memory.init: 2 byte opcode + 1 byte segment index + 1 byte memory index + +// 3 x 2 byte operands +const size_t MEMORY_INIT_SIZE = 10; + +// memory.fill: 2 byte opcode + 1 byte memory index + 3 x 2 byte operands +const size_t MEMORY_FILL_SIZE = 9; + +// data.drop: 2 byte opcode + ~1 byte index immediate +const size_t DATA_DROP_SIZE = 3; + +namespace { + +Expression* +makeGtShiftedMemorySize(Builder& builder, Module& module, MemoryInit* curr) { + return builder.makeBinary( + module.memory.is64() ? GtUInt64 : GtUInt32, + curr->dest, + builder.makeBinary(module.memory.is64() ? ShlInt64 : ShlInt32, + builder.makeMemorySize(), + builder.makeConstPtr(16))); +} + +} // anonymous namespace + +struct MemoryPacking : public Pass { + size_t dropStateGlobalCount = 0; + + // FIXME: Chrome has a bug decoding section indices that prevents it from + // using more than 63. Just use WebLimitations::MaxDataSegments once this is + // fixed. See https://bugs.chromium.org/p/v8/issues/detail?id=10151. + uint32_t maxSegments; + + void run(PassRunner* runner, Module* module) override; + void optimizeBulkMemoryOps(PassRunner* runner, Module* module); + void getSegmentReferrers(Module* module, std::vector& referrers); + void dropUnusedSegments(std::vector& segments, + std::vector& referrers); + bool canSplit(const Memory::Segment& segment, const Referrers& referrers); + void calculateRanges(const Memory::Segment& segment, + const Referrers& referrers, + std::vector& ranges); + void createSplitSegments(Builder& builder, + const Memory::Segment& segment, + std::vector& ranges, + std::vector& packed, + size_t segmentsRemaining); + void createReplacements(Module* module, + const std::vector& ranges, + const Referrers& referrers, + Replacements& replacements, + const Index segmentIndex); + void replaceBulkMemoryOps(PassRunner* runner, + Module* module, + Replacements& replacements); +}; + +void MemoryPacking::run(PassRunner* runner, Module* module) { + if (!module->memory.exists) { + return; + } + + maxSegments = module->features.hasBulkMemory() + ? 63 + : uint32_t(WebLimitations::MaxDataSegments); + auto& segments = module->memory.segments; + + // For each segment, a list of bulk memory instructions that refer to it + std::vector referrers(segments.size()); + + if (module->features.hasBulkMemory()) { + // Optimize out memory.inits and data.drops that can be entirely replaced + // with other instruction sequences. This can increase the number of unused + // segments that can be dropped entirely and allows later replacement + // creation to make more assumptions about what these instructions will look + // like, such as memory.inits not having both zero offset and size. + optimizeBulkMemoryOps(runner, module); + getSegmentReferrers(module, referrers); + dropUnusedSegments(segments, referrers); + } + + // The new, split memory segments + std::vector packed; + + Replacements replacements; + Builder builder(*module); + for (size_t origIndex = 0; origIndex < segments.size(); ++origIndex) { + auto& segment = segments[origIndex]; + auto& currReferrers = referrers[origIndex]; + + std::vector ranges; + if (canSplit(segment, currReferrers)) { + calculateRanges(segment, currReferrers, ranges); + } else { + // A single range covers the entire segment. Set isZero to false so the + // original memory.init will be used even if segment is all zeroes. + ranges.push_back({false, 0, segment.data.size()}); + } + + Index firstNewIndex = packed.size(); + size_t segmentsRemaining = segments.size() - origIndex; + createSplitSegments(builder, segment, ranges, packed, segmentsRemaining); + createReplacements( + module, ranges, currReferrers, replacements, firstNewIndex); + } + + segments.swap(packed); + + if (module->features.hasBulkMemory()) { + replaceBulkMemoryOps(runner, module, replacements); + } +} + +bool MemoryPacking::canSplit(const Memory::Segment& segment, + const Referrers& referrers) { + if (segment.isPassive) { + for (auto* referrer : referrers) { + if (auto* init = referrer->dynCast()) { + // Do not try to split if there is a nonconstant offset or size + if (!init->offset->is() || !init->size->is()) { + return false; + } + } + } + return true; + } else { + // Active segments can only be split if they have constant offsets + return segment.offset->is(); + } +} + +void MemoryPacking::calculateRanges(const Memory::Segment& segment, + const Referrers& referrers, + std::vector& ranges) { + auto& data = segment.data; + if (data.size() == 0) { + return; + } + + // Calculate initial zero and nonzero ranges + size_t start = 0; + while (start < data.size()) { + size_t end = start; + while (end < data.size() && data[end] == 0) { + end++; + } + if (end > start) { + ranges.push_back({true, start, end}); + start = end; + } + while (end < data.size() && data[end] != 0) { + end++; + } + if (end > start) { + ranges.push_back({false, start, end}); + start = end; + } + } + + // Calculate the number of consecutive zeroes for which splitting is + // beneficial. This is an approximation that assumes all memory.inits cover an + // entire segment and that all its arguments are constants. These assumptions + // are true of all memory.inits generated by the tools. + size_t threshold = 0; + if (segment.isPassive) { + // Passive segment metadata size + threshold += 2; + // Zeroes on the edge do not increase the number of segments or data.drops, + // so their threshold is lower. The threshold for interior zeroes depends on + // an estimate of the number of new memory.fill and data.drop instructions + // splitting would introduce. + size_t edgeThreshold = 0; + for (auto* referrer : referrers) { + if (referrer->is()) { + // Splitting adds a new memory.fill and a new memory.init + threshold += MEMORY_FILL_SIZE + MEMORY_INIT_SIZE; + edgeThreshold += MEMORY_FILL_SIZE; + } else { + threshold += DATA_DROP_SIZE; + } + } + + // Merge edge zeroes if they are not worth splitting + if (ranges.size() >= 2) { + auto last = ranges.end() - 1; + auto penultimate = ranges.end() - 2; + if (last->isZero && last->end - last->start <= edgeThreshold) { + penultimate->end = last->end; + ranges.erase(last); + } + } + if (ranges.size() >= 2) { + auto first = ranges.begin(); + auto second = ranges.begin() + 1; + if (first->isZero && first->end - first->start <= edgeThreshold) { + second->start = first->start; + ranges.erase(first); + } + } + } else { + // Legacy ballpark overhead of active segment with offset + // TODO: Tune this + threshold = 8; + } + + // Merge ranges across small spans of zeroes + std::vector mergedRanges = {ranges.front()}; + size_t i; + for (i = 1; i < ranges.size() - 1; ++i) { + auto left = mergedRanges.end() - 1; + auto curr = ranges.begin() + i; + auto right = ranges.begin() + i + 1; + if (curr->isZero && curr->end - curr->start <= threshold) { + left->end = right->end; + ++i; + } else { + mergedRanges.push_back(*curr); + } + } + // Add the final range if it hasn't already been merged in + if (i < ranges.size()) { + mergedRanges.push_back(ranges.back()); + } + std::swap(ranges, mergedRanges); +} + +void MemoryPacking::optimizeBulkMemoryOps(PassRunner* runner, Module* module) { + struct Optimizer : WalkerPass> { + bool isFunctionParallel() override { return true; } + Pass* create() override { return new Optimizer; } + + bool needsRefinalizing; + + void visitMemoryInit(MemoryInit* curr) { + Builder builder(*getModule()); + Memory::Segment& segment = getModule()->memory.segments[curr->segment]; + size_t maxRuntimeSize = segment.isPassive ? segment.data.size() : 0; + bool mustNop = false; + bool mustTrap = false; + auto* offset = curr->offset->dynCast(); + auto* size = curr->size->dynCast(); + if (offset && uint32_t(offset->value.geti32()) > maxRuntimeSize) { + mustTrap = true; + } + if (size && uint32_t(size->value.geti32()) > maxRuntimeSize) { + mustTrap = true; + } + if (offset && size) { + uint64_t offsetVal(offset->value.geti32()); + uint64_t sizeVal(size->value.geti32()); + if (offsetVal + sizeVal > maxRuntimeSize) { + mustTrap = true; + } else if (offsetVal == 0 && sizeVal == 0) { + mustNop = true; + } + } + assert(!mustNop || !mustTrap); + if (mustNop) { + // Offset and size are 0, so just trap if dest > memory.size + replaceCurrent( + builder.makeIf(makeGtShiftedMemorySize(builder, *getModule(), curr), + builder.makeUnreachable())); + } else if (mustTrap) { + // Drop dest, offset, and size then trap + replaceCurrent(builder.blockify(builder.makeDrop(curr->dest), + builder.makeDrop(curr->offset), + builder.makeDrop(curr->size), + builder.makeUnreachable())); + needsRefinalizing = true; + } else if (!segment.isPassive) { + // trap if (dest > memory.size | offset | size) != 0 + replaceCurrent(builder.makeIf( + builder.makeBinary( + OrInt32, + makeGtShiftedMemorySize(builder, *getModule(), curr), + builder.makeBinary(OrInt32, curr->offset, curr->size)), + builder.makeUnreachable())); + } + } + void visitDataDrop(DataDrop* curr) { + if (!getModule()->memory.segments[curr->segment].isPassive) { + ExpressionManipulator::nop(curr); + } + } + void doWalkFunction(Function* func) { + needsRefinalizing = false; + super::doWalkFunction(func); + if (needsRefinalizing) { + ReFinalize().walkFunctionInModule(func, getModule()); + } + } + } optimizer; + optimizer.run(runner, module); +} + +void MemoryPacking::getSegmentReferrers(Module* module, + std::vector& referrers) { + auto collectReferrers = [&](Function* func, + std::vector& referrers) { + if (func->imported()) { + return; + } + struct Collector : WalkerPass> { + std::vector& referrers; + Collector(std::vector& referrers) : referrers(referrers) {} + + void visitMemoryInit(MemoryInit* curr) { + referrers[curr->segment].push_back(curr); + } + void visitDataDrop(DataDrop* curr) { + referrers[curr->segment].push_back(curr); + } + void doWalkFunction(Function* func) { + referrers.resize(getModule()->memory.segments.size()); + super::doWalkFunction(func); + } + } collector(referrers); + collector.walkFunctionInModule(func, module); + }; + ModuleUtils::ParallelFunctionAnalysis> analysis( + *module, collectReferrers); + referrers.resize(module->memory.segments.size()); + for (auto& pair : analysis.map) { + std::vector& funcReferrers = pair.second; + for (size_t i = 0; i < funcReferrers.size(); ++i) { + referrers[i].insert( + referrers[i].end(), funcReferrers[i].begin(), funcReferrers[i].end()); + } + } +} + +void MemoryPacking::dropUnusedSegments(std::vector& segments, + std::vector& referrers) { + std::vector usedSegments; + std::vector usedReferrers; + // Remove segments that are never used + // TODO: remove unused portions of partially used segments as well + for (size_t i = 0; i < segments.size(); ++i) { + bool used = false; + if (segments[i].isPassive) { + for (auto* referrer : referrers[i]) { + if (referrer->is()) { + used = true; + break; + } + } + } else { + used = true; + } + if (used) { + usedSegments.push_back(segments[i]); + usedReferrers.push_back(referrers[i]); + } else { + // All referrers are data.drops. Make them nops. + for (auto* referrer : referrers[i]) { + ExpressionManipulator::nop(referrer); + } + } + } + std::swap(segments, usedSegments); + std::swap(referrers, usedReferrers); +} + +void MemoryPacking::createSplitSegments(Builder& builder, + const Memory::Segment& segment, + std::vector& ranges, + std::vector& packed, + size_t segmentsRemaining) { + for (size_t i = 0; i < ranges.size(); ++i) { + Range& range = ranges[i]; + if (range.isZero) { + continue; + } + Expression* offset = nullptr; + if (!segment.isPassive) { + if (auto* c = segment.offset->dynCast()) { + offset = builder.makeConst(int32_t(c->value.geti32() + range.start)); + } else { + assert(ranges.size() == 1); + offset = segment.offset; + } + } + if (maxSegments <= packed.size() + segmentsRemaining) { + // Give up splitting and merge all remaining ranges except end zeroes + auto lastNonzero = ranges.end() - 1; + if (lastNonzero->isZero) { + --lastNonzero; + } + range.end = lastNonzero->end; + ranges.erase(ranges.begin() + i + 1, lastNonzero + 1); + } + packed.emplace_back(segment.isPassive, + offset, + &segment.data[range.start], + range.end - range.start); + } +} + +void MemoryPacking::createReplacements(Module* module, + const std::vector& ranges, + const Referrers& referrers, + Replacements& replacements, + const Index segmentIndex) { + // If there was no transformation, only update the indices + if (ranges.size() == 1 && !ranges.front().isZero) { + for (auto referrer : referrers) { + replacements[referrer] = [referrer, segmentIndex](Function*) { + if (auto* init = referrer->dynCast()) { + init->segment = segmentIndex; + } else if (auto* drop = referrer->dynCast()) { + drop->segment = segmentIndex; + } else { + WASM_UNREACHABLE("Unexpected bulk memory operation"); + } + return referrer; + }; + } + return; + } + + Builder builder(*module); + + Name dropStateGlobal; + + // Return the drop state global, initializing it if it does not exist. This + // may change module-global state and has the important side effect of setting + // dropStateGlobal, so it must be evaluated eagerly, not in the replacements. + auto getDropStateGlobal = [&]() { + if (dropStateGlobal != Name()) { + return dropStateGlobal; + } + dropStateGlobal = Name(std::string("__mem_segment_drop_state_") + + std::to_string(dropStateGlobalCount++)); + module->addGlobal(builder.makeGlobal(dropStateGlobal, + Type::i32, + builder.makeConst(int32_t(0)), + Builder::Mutable)); + return dropStateGlobal; + }; + + // Create replacements for memory.init instructions first + for (auto referrer : referrers) { + auto* init = referrer->dynCast(); + if (init == nullptr) { + continue; + } + + // Nonconstant offsets or sizes will have inhibited splitting + size_t start = init->offset->cast()->value.geti32(); + size_t end = start + init->size->cast()->value.geti32(); + + // Index of the range from which this memory.init starts reading + size_t firstRangeIdx = 0; + while (firstRangeIdx < ranges.size() && + ranges[firstRangeIdx].end <= start) { + ++firstRangeIdx; + } + + // Handle zero-length memory.inits separately so we can later assume that + // start is in bounds and that some range will be intersected. + if (start == end) { + // Offset is nonzero because init would otherwise have previously been + // optimized out, so trap if the dest is out of bounds or the segment is + // dropped + Expression* result = builder.makeIf( + builder.makeBinary( + OrInt32, + makeGtShiftedMemorySize(builder, *module, init), + builder.makeGlobalGet(getDropStateGlobal(), Type::i32)), + builder.makeUnreachable()); + replacements[init] = [result](Function*) { return result; }; + continue; + } + + assert(firstRangeIdx < ranges.size()); + + // Split init into multiple memory.inits and memory.fills, storing the + // original base destination in a local if it is not a constant. If the + // first access is a memory.fill, explicitly check the drop status first to + // avoid writing zeroes when we should have trapped. + Expression* result = nullptr; + auto appendResult = [&](Expression* expr) { + result = result ? builder.blockify(result, expr) : expr; + }; + + // The local var holding the dest is not known until replacement time. Keep + // track of the locations where it will need to be patched in. + Index* setVar = nullptr; + std::vector getVars; + if (!init->dest->is()) { + auto set = builder.makeLocalSet(-1, init->dest); + setVar = &set->index; + appendResult(set); + } + + // We only need to explicitly check the drop state when we will emit + // memory.fill first, since memory.init will implicitly do the check for us. + if (ranges[firstRangeIdx].isZero) { + appendResult( + builder.makeIf(builder.makeGlobalGet(getDropStateGlobal(), Type::i32), + builder.makeUnreachable())); + } + + size_t bytesWritten = 0; + + size_t initIndex = segmentIndex; + for (size_t i = firstRangeIdx; i < ranges.size() && ranges[i].start < end; + ++i) { + auto& range = ranges[i]; + + // Calculate dest, either as a const or as an addition to the dest local + Expression* dest; + if (auto* c = init->dest->dynCast()) { + dest = builder.makeConst(int32_t(c->value.geti32() + bytesWritten)); + } else { + auto* get = builder.makeLocalGet(-1, Type::i32); + getVars.push_back(&get->index); + dest = get; + if (bytesWritten > 0) { + Const* addend = builder.makeConst(int32_t(bytesWritten)); + dest = builder.makeBinary(AddInt32, dest, addend); + } + } + + // How many bytes are read from this range + size_t bytes = std::min(range.end, end) - std::max(range.start, start); + Expression* size = builder.makeConst(int32_t(bytes)); + bytesWritten += bytes; + + // Create new memory.init or memory.fill + if (range.isZero) { + Expression* value = builder.makeConst(Literal::makeZero(Type::i32)); + appendResult(builder.makeMemoryFill(dest, value, size)); + } else { + size_t offsetBytes = std::max(start, range.start) - range.start; + Expression* offset = builder.makeConst(int32_t(offsetBytes)); + appendResult(builder.makeMemoryInit(initIndex, dest, offset, size)); + initIndex++; + } + } + + // Non-zero length memory.inits must have intersected some range + assert(result); + replacements[init] = [module, setVar, getVars, result](Function* function) { + if (setVar != nullptr) { + Index destVar = Builder(*module).addVar(function, Type::i32); + *setVar = destVar; + for (auto* getVar : getVars) { + *getVar = destVar; + } + } + return result; + }; + } + + // Create replacements for data.drop instructions now that we know whether we + // need a drop state global + for (auto drop : referrers) { + if (!drop->is()) { + continue; + } + + Expression* result = nullptr; + auto appendResult = [&](Expression* expr) { + result = result ? builder.blockify(result, expr) : expr; + }; + + // Track drop state in a global only if some memory.init required it + if (dropStateGlobal != Name()) { + appendResult( + builder.makeGlobalSet(dropStateGlobal, builder.makeConst(int32_t(1)))); + } + size_t dropIndex = segmentIndex; + for (auto range : ranges) { + if (!range.isZero) { + appendResult(builder.makeDataDrop(dropIndex++)); + } + } + replacements[drop] = [result, module](Function*) { + return result ? result : Builder(*module).makeNop(); + }; + } +} + +void MemoryPacking::replaceBulkMemoryOps(PassRunner* runner, + Module* module, + Replacements& replacements) { + struct Replacer : WalkerPass> { + bool isFunctionParallel() override { return true; } + + Replacements& replacements; + + Replacer(Replacements& replacements) : replacements(replacements){}; + Pass* create() override { return new Replacer(replacements); } + + void visitMemoryInit(MemoryInit* curr) { + auto replacement = replacements.find(curr); + assert(replacement != replacements.end()); + replaceCurrent(replacement->second(getFunction())); + } + + void visitDataDrop(DataDrop* curr) { + auto replacement = replacements.find(curr); + assert(replacement != replacements.end()); + replaceCurrent(replacement->second(getFunction())); + } + } replacer(replacements); + replacer.run(runner, module); +} + +Pass* createMemoryPackingPass() { return new MemoryPacking(); } + +} // namespace wasm diff --git a/binaryen/src/passes/MergeBlocks.cpp b/binaryen/src/passes/MergeBlocks.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/passes/MergeBlocks.cpp @@ -0,0 +1,603 @@ +/* + * Copyright 2015 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// Merges blocks to their parents. +// +// We merge both entire blocks when possible, as well as loop tails, like +// (block +// (loop $child +// (br_if $child (..) +// (call $foo) +// ) +// ) +// Here we can move the call into the outer block. Doing so may let +// the inner block become a single expression, and usually outer +// blocks are larger anyhow. (This also helps readability.) +// +// We also restructure blocks in order to enable such merging. For +// example, +// +// (i32.store +// (block +// (call $foo) +// (i32.load (i32.const 100)) +// ) +// (i32.const 0) +// ) +// +// can be transformed into +// +// (block +// (call $foo) +// (i32.store +// (block +// (i32.load (i32.const 100)) +// ) +// (i32.const 0) +// ) +// ) +// +// after which the internal block can go away, and +// the new external block might be mergeable. This is always +// worth it if the internal block ends up with 1 item. +// For the second operand, +// +// (i32.store +// (i32.const 100) +// (block +// (call $foo) +// (i32.load (i32.const 200)) +// ) +// ) +// +// The order of operations requires that the first execute +// before. We can do the same operation, but only if the +// first has no side effects, or the code we are moving out +// has no side effects. +// If we can do this to both operands, we can generate a +// single outside block. +// + +#include +#include +#include +#include +#include +#include + +namespace wasm { + +// Looks for reasons we can't remove the values from breaks to an origin +// For example, if there is a switch targeting us, we can't do it - we can't +// remove the value from other targets +struct ProblemFinder : public ControlFlowWalker { + Name origin; + bool foundProblem = false; + // count br_ifs, and dropped br_ifs. if they don't match, then a br_if flow + // value is used, and we can't drop it + Index brIfs = 0; + Index droppedBrIfs = 0; + PassOptions& passOptions; + + ProblemFinder(PassOptions& passOptions) : passOptions(passOptions) {} + + void visitBreak(Break* curr) { + if (curr->name == origin) { + if (curr->condition) { + brIfs++; + } + // if the value has side effects, we can't remove it + if (EffectAnalyzer(passOptions, getModule()->features, curr->value) + .hasSideEffects()) { + foundProblem = true; + } + } + } + + void visitDrop(Drop* curr) { + if (auto* br = curr->value->dynCast()) { + if (br->name == origin && br->condition) { + droppedBrIfs++; + } + } + } + + void visitSwitch(Switch* curr) { + if (curr->default_ == origin) { + foundProblem = true; + return; + } + for (auto& target : curr->targets) { + if (target == origin) { + foundProblem = true; + return; + } + } + } + + void visitBrOnExn(BrOnExn* curr) { + // We should not take exnref value out of br_on_exn + foundProblem = true; + } + + bool found() { + assert(brIfs >= droppedBrIfs); + return foundProblem || brIfs > droppedBrIfs; + } +}; + +// Drops values from breaks to an origin. +// While doing so it can create new blocks, so optimize blocks as well. +struct BreakValueDropper : public ControlFlowWalker { + Name origin; + PassOptions& passOptions; + BranchUtils::BranchSeekerCache& branchInfo; + + BreakValueDropper(PassOptions& passOptions, + BranchUtils::BranchSeekerCache& branchInfo) + : passOptions(passOptions), branchInfo(branchInfo) {} + + void visitBlock(Block* curr); + + void visitBreak(Break* curr) { + if (curr->value && curr->name == origin) { + Builder builder(*getModule()); + auto* value = curr->value; + if (value->type == Type::unreachable) { + // the break isn't even reached + replaceCurrent(value); + return; + } + curr->value = nullptr; + curr->finalize(); + replaceCurrent(builder.makeSequence(builder.makeDrop(value), curr)); + } + } + + void visitDrop(Drop* curr) { + // if we dropped a br_if whose value we removed, then we are now dropping a + // (block (drop value) (br_if)) with type none, which does not need a drop + // likewise, unreachable does not need to be dropped, so we just leave drops + // of concrete values + if (!curr->value->type.isConcrete()) { + replaceCurrent(curr->value); + } + } +}; + +static bool hasUnreachableChild(Block* block) { + for (auto* test : block->list) { + if (test->type == Type::unreachable) { + return true; + } + } + return false; +} + +// Checks for code after an unreachable element. +static bool hasDeadCode(Block* block) { + auto& list = block->list; + auto size = list.size(); + for (size_t i = 1; i < size; i++) { + if (list[i - 1]->type == Type::unreachable) { + return true; + } + } + return false; +} + +// core block optimizer routine +static void optimizeBlock(Block* curr, + Module* module, + PassOptions& passOptions, + BranchUtils::BranchSeekerCache& branchInfo) { + auto& list = curr->list; + // Main merging loop. + bool more = true; + bool changed = false; + while (more) { + more = false; + for (size_t i = 0; i < list.size(); i++) { + auto* child = list[i]; + // The child block, if there is one. + Block* childBlock = child->dynCast(); + // If we are merging an inner block of a loop, then we must not + // merge things before and including the name of the loop, moving + // those out would break things. + Loop* loop = nullptr; + // To to handle a non-block child. + if (!childBlock) { + // if we have a child that is (drop (block ..)) then we can move the + // drop into the block, and remove br values. this allows more merging, + if (auto* drop = list[i]->dynCast()) { + childBlock = drop->value->dynCast(); + if (childBlock) { + if (hasUnreachableChild(childBlock)) { + // don't move around unreachable code, as it can change types + // dce should have been run anyhow + continue; + } + if (childBlock->name.is()) { + Expression* expression = childBlock; + // check if it's ok to remove the value from all breaks to us + ProblemFinder finder(passOptions); + finder.setModule(module); + finder.origin = childBlock->name; + finder.walk(expression); + if (finder.found()) { + childBlock = nullptr; + } else { + // fix up breaks + BreakValueDropper fixer(passOptions, branchInfo); + fixer.origin = childBlock->name; + fixer.setModule(module); + fixer.walk(expression); + } + } + if (childBlock) { + // we can do it! + // reuse the drop, if we still need it + auto* last = childBlock->list.back(); + if (last->type.isConcrete()) { + drop->value = last; + drop->finalize(); + childBlock->list.back() = drop; + } + childBlock->finalize(); + child = list[i] = childBlock; + more = true; + changed = true; + } + } + } else if ((loop = list[i]->dynCast())) { + // We can merge a loop's "tail" - if the body is a block and has + // instructions at the end that do not branch back. + childBlock = loop->body->dynCast(); + // TODO: handle (loop (loop - the bodies of loops may not be blocks + } + } + // If no block, we can't do anything. + if (!childBlock) { + continue; + } + auto& childList = childBlock->list; + auto childSize = childList.size(); + if (childSize == 0) { + continue; + } + // If the child has items after an unreachable, ignore it - dce should + // have been run, and we prefer to not handle the complexity here. + if (hasDeadCode(childBlock)) { + continue; + } + // In some cases we can remove only the head or the tail of the block, + // and must keep some things in the child block. + Index keepStart = childSize; + Index keepEnd = 0; + // For a block with a name, we may only be able to remove a head, up + // to the first item that branches to the block. + if (childBlock->name.is()) { + // If it has a concrete value, then breaks may be sending it a value, + // and we'd need to handle that. TODO + if (childBlock->type.isConcrete()) { + continue; + } + auto childName = childBlock->name; + for (size_t j = 0; j < childSize; j++) { + auto* item = childList[j]; + if (branchInfo.hasBranch(item, childName)) { + // We can't remove this from the child. + keepStart = j; + keepEnd = childSize; + break; + } + } + } + // For a loop, we may only be able to remove a tail + if (loop) { + auto childName = loop->name; + for (auto j = int(childSize - 1); j >= 0; j--) { + auto* item = childList[j]; + if (BranchUtils::BranchSeeker::has(item, childName)) { + // We can't remove this from the child. + keepStart = 0; + keepEnd = std::max(Index(j + 1), keepEnd); + break; + } + } + // If we can only do part of the block, and if the block has a flowing + // value, we would need special handling for that - not worth it, + // probably TODO + // FIXME is this not handled by the drop later down? + if (keepEnd < childSize && childList.back()->type.isConcrete()) { + continue; + } + } + // Maybe there's nothing to do, if we must keep it all in the + // child anyhow. + if (keepStart == 0 && keepEnd == childSize) { + continue; + } + // There is something to do! + bool keepingPart = keepStart < keepEnd; + // Create a new merged list, and fill in the code before the + // child block we are merging in. TODO better efficiency + ExpressionList merged(module->allocator); + for (size_t j = 0; j < i; j++) { + merged.push_back(list[j]); + } + // Add the head of the block - the things at the start we do + // not need to keep. + for (Index j = 0; j < keepStart; j++) { + merged.push_back(childList[j]); + } + // If we can't merge it all, keep and filter the child. + if (keepingPart) { + merged.push_back(child); + // Filter the child. + ExpressionList filtered(module->allocator); + for (Index j = keepStart; j < keepEnd; j++) { + filtered.push_back(childList[j]); + } + // Add the tail of the block - the things at the end we do + // not need to keep. + for (Index j = keepEnd; j < childSize; j++) { + merged.push_back(childList[j]); + } + // Update the child. + childList.swap(filtered); + // We may have removed unreachable items. + childBlock->finalize(); + if (loop) { + loop->finalize(); + } + // Note that we modify the child block here, which invalidates info + // in branchInfo. However, as we have scanned the parent, we have + // already forgotten the child's info, so there is nothing to do here + // for the child. + // (We also don't need to do anything for the parent - we move code + // from a child into the parent, but that doesn't change the total + // branches in the parent.) + } + // Add the rest of the parent block after the child. + for (size_t j = i + 1; j < list.size(); j++) { + merged.push_back(list[j]); + } + // if we merged a concrete element in the middle, drop it + if (!merged.empty()) { + auto* last = merged.back(); + for (auto*& item : merged) { + if (item != last && item->type.isConcrete()) { + Builder builder(*module); + item = builder.makeDrop(item); + } + } + } + list.swap(merged); + more = true; + changed = true; + break; + } + } + if (changed) { + curr->finalize(curr->type); + } +} + +void BreakValueDropper::visitBlock(Block* curr) { + optimizeBlock(curr, getModule(), passOptions, branchInfo); +} + +struct MergeBlocks : public WalkerPass> { + bool isFunctionParallel() override { return true; } + + Pass* create() override { return new MergeBlocks; } + + BranchUtils::BranchSeekerCache branchInfo; + + void visitBlock(Block* curr) { + optimizeBlock(curr, getModule(), getPassOptions(), branchInfo); + } + + // given + // (curr + // (block=child + // (..more..) + // (back) + // ) + // (..other..children..) + // ) + // if child is a block, we can move this around to + // (block + // (..more..) + // (curr + // (back) + // (..other..children..) + // ) + // ) + // at which point the block is on the outside and potentially mergeable with + // an outer block + Block* optimize(Expression* curr, + Expression*& child, + Block* outer = nullptr, + Expression** dependency1 = nullptr, + Expression** dependency2 = nullptr) { + if (!child) { + return outer; + } + FeatureSet features = getModule()->features; + if ((dependency1 && *dependency1) || (dependency2 && *dependency2)) { + // there are dependencies, things we must be reordered through. make sure + // no problems there + EffectAnalyzer childEffects(getPassOptions(), features, child); + if (dependency1 && *dependency1 && + EffectAnalyzer(getPassOptions(), features, *dependency1) + .invalidates(childEffects)) { + return outer; + } + if (dependency2 && *dependency2 && + EffectAnalyzer(getPassOptions(), features, *dependency2) + .invalidates(childEffects)) { + return outer; + } + } + if (auto* block = child->dynCast()) { + if (!block->name.is() && block->list.size() >= 2) { + // if we move around unreachable code, type changes could occur. avoid + // that, as anyhow it means we should have run dce before getting here + if (curr->type == Type::none && hasUnreachableChild(block)) { + // moving the block to the outside would replace a none with an + // unreachable + return outer; + } + auto* back = block->list.back(); + if (back->type == Type::unreachable) { + // curr is not reachable, dce could remove it; don't try anything + // fancy here + return outer; + } + // we are going to replace the block with the final element, so they + // should be identically typed + if (block->type != back->type) { + return outer; + } + child = back; + if (outer == nullptr) { + // reuse the block, move it out + block->list.back() = curr; + // we want the block outside to have the same type as curr had + block->finalize(curr->type); + replaceCurrent(block); + return block; + } else { + // append to an existing outer block + assert(outer->list.back() == curr); + outer->list.pop_back(); + for (Index i = 0; i < block->list.size() - 1; i++) { + outer->list.push_back(block->list[i]); + } + outer->list.push_back(curr); + } + } + } + return outer; + } + + void visitUnary(Unary* curr) { optimize(curr, curr->value); } + void visitLocalSet(LocalSet* curr) { optimize(curr, curr->value); } + void visitLoad(Load* curr) { optimize(curr, curr->ptr); } + void visitReturn(Return* curr) { optimize(curr, curr->value); } + + void visitBinary(Binary* curr) { + optimize(curr, curr->right, optimize(curr, curr->left), &curr->left); + } + void visitStore(Store* curr) { + optimize(curr, curr->value, optimize(curr, curr->ptr), &curr->ptr); + } + void visitAtomicRMW(AtomicRMW* curr) { + optimize(curr, curr->value, optimize(curr, curr->ptr), &curr->ptr); + } + void optimizeTernary(Expression* curr, + Expression*& first, + Expression*& second, + Expression*& third) { + // TODO: for now, just stop when we see any side effect. instead, we could + // check effects carefully for reordering + FeatureSet features = getModule()->features; + Block* outer = nullptr; + if (EffectAnalyzer(getPassOptions(), features, first).hasSideEffects()) { + return; + } + outer = optimize(curr, first, outer); + if (EffectAnalyzer(getPassOptions(), features, second).hasSideEffects()) { + return; + } + outer = optimize(curr, second, outer); + if (EffectAnalyzer(getPassOptions(), features, third).hasSideEffects()) { + return; + } + optimize(curr, third, outer); + } + void visitAtomicCmpxchg(AtomicCmpxchg* curr) { + optimizeTernary(curr, curr->ptr, curr->expected, curr->replacement); + } + + void visitSelect(Select* curr) { + optimizeTernary(curr, curr->ifTrue, curr->ifFalse, curr->condition); + } + + void visitDrop(Drop* curr) { optimize(curr, curr->value); } + + void visitBreak(Break* curr) { + optimize(curr, curr->condition, optimize(curr, curr->value), &curr->value); + } + + void visitSwitch(Switch* curr) { + optimize(curr, curr->condition, optimize(curr, curr->value), &curr->value); + } + + template void handleCall(T* curr) { + Block* outer = nullptr; + for (Index i = 0; i < curr->operands.size(); i++) { + if (EffectAnalyzer( + getPassOptions(), getModule()->features, curr->operands[i]) + .hasSideEffects()) { + return; + } + outer = optimize(curr, curr->operands[i], outer); + } + } + + void visitCall(Call* curr) { handleCall(curr); } + + void visitCallIndirect(CallIndirect* curr) { + FeatureSet features = getModule()->features; + Block* outer = nullptr; + for (Index i = 0; i < curr->operands.size(); i++) { + if (EffectAnalyzer(getPassOptions(), features, curr->operands[i]) + .hasSideEffects()) { + return; + } + outer = optimize(curr, curr->operands[i], outer); + } + if (EffectAnalyzer(getPassOptions(), features, curr->target) + .hasSideEffects()) { + return; + } + optimize(curr, curr->target, outer); + } + + void visitThrow(Throw* curr) { + Block* outer = nullptr; + for (Index i = 0; i < curr->operands.size(); i++) { + if (EffectAnalyzer( + getPassOptions(), getModule()->features, curr->operands[i]) + .hasSideEffects()) { + return; + } + outer = optimize(curr, curr->operands[i], outer); + } + } + + void visitRethrow(Rethrow* curr) { optimize(curr, curr->exnref); } + + void visitBrOnExn(BrOnExn* curr) { optimize(curr, curr->exnref); } +}; + +Pass* createMergeBlocksPass() { return new MergeBlocks(); } + +} // namespace wasm diff --git a/binaryen/src/passes/MergeLocals.cpp b/binaryen/src/passes/MergeLocals.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/passes/MergeLocals.cpp @@ -0,0 +1,236 @@ +/* + * Copyright 2016 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// Merges locals when it is beneficial to do so. +// +// An obvious case is when locals are copied. In that case, two locals have the +// same value in a range, and we can pick which of the two to use. For +// example, in +// +// (if (result i32) +// (local.tee $x +// (local.get $y) +// ) +// (i32.const 100) +// (local.get $x) +// ) +// +// If that assignment of $y is never used again, everything is fine. But if +// if is, then the live range of $y does not end in that get, and will +// necessarily overlap with that of $x - making them appear to interfere +// with each other in coalesce-locals, even though the value is identical. +// +// To fix that, we replace uses of $y with uses of $x. This extends $x's +// live range and shrinks $y's live range. This tradeoff is not always good, +// but $x and $y definitely overlap already, so trying to shrink the overlap +// makes sense - if we remove the overlap entirely, we may be able to let +// $x and $y be coalesced later. +// +// If we can remove only some of $y's uses, then we are definitely not +// removing the overlap, and they do conflict. In that case, it's not clear +// if this is beneficial or not, and we don't do it for now +// TODO: investigate more +// + +#include +#include +#include +#include + +namespace wasm { + +struct MergeLocals + : public WalkerPass< + PostWalker>> { + bool isFunctionParallel() override { return true; } + + Pass* create() override { return new MergeLocals(); } + + void doWalkFunction(Function* func) { + // first, instrument the graph by modifying each copy + // (local.set $x + // (local.get $y) + // ) + // to + // (local.set $x + // (local.tee $y + // (local.get $y) + // ) + // ) + // That is, we add a trivial assign of $y. This ensures we + // have a new assignment of $y at the location of the copy, + // which makes it easy for us to see if the value if $y + // is still used after that point + super::doWalkFunction(func); + + // optimize the copies, merging when we can, and removing + // the trivial assigns we added temporarily + optimizeCopies(); + } + + std::vector copies; + + void visitLocalSet(LocalSet* curr) { + if (auto* get = curr->value->dynCast()) { + if (get->index != curr->index) { + Builder builder(*getModule()); + auto* trivial = builder.makeLocalTee(get->index, get, get->type); + curr->value = trivial; + copies.push_back(curr); + } + } + } + + void optimizeCopies() { + if (copies.empty()) { + return; + } + // compute all dependencies + auto* func = getFunction(); + LocalGraph preGraph(func); + preGraph.computeInfluences(); + // optimize each copy + std::unordered_map optimizedToCopy, + optimizedToTrivial; + for (auto* copy : copies) { + auto* trivial = copy->value->cast(); + bool canOptimizeToCopy = false; + auto& trivialInfluences = preGraph.setInfluences[trivial]; + if (!trivialInfluences.empty()) { + canOptimizeToCopy = true; + for (auto* influencedGet : trivialInfluences) { + // this get uses the trivial write, so it uses the value in the copy. + // however, it may depend on other writes too, if there is a + // merge/phi, and in that case we can't do anything + assert(influencedGet->index == trivial->index); + if (preGraph.getSetses[influencedGet].size() == 1) { + // this is ok + assert(*preGraph.getSetses[influencedGet].begin() == trivial); + // If local types are different (when one is a subtype of the + // other), don't optimize + if (func->getLocalType(copy->index) != influencedGet->type) { + canOptimizeToCopy = false; + } + } else { + canOptimizeToCopy = false; + break; + } + } + } + if (canOptimizeToCopy) { + // worth it for this copy, do it + for (auto* influencedGet : trivialInfluences) { + influencedGet->index = copy->index; + } + optimizedToCopy[copy] = trivial; + } else { + // alternatively, we can try to remove the conflict in the opposite way: + // given + // (local.set $x + // (local.get $y) + // ) + // we can look for uses of $x that could instead be uses of $y. this + // extends $y's live range, but if it removes the conflict between $x + // and $y, it may be worth it + + // if the trivial set we added has influences, it means $y lives on + if (!trivialInfluences.empty()) { + auto& copyInfluences = preGraph.setInfluences[copy]; + if (!copyInfluences.empty()) { + bool canOptimizeToTrivial = true; + for (auto* influencedGet : copyInfluences) { + // as above, avoid merges/phis + assert(influencedGet->index == copy->index); + if (preGraph.getSetses[influencedGet].size() == 1) { + // this is ok + assert(*preGraph.getSetses[influencedGet].begin() == copy); + // If local types are different (when one is a subtype of the + // other), don't optimize + if (func->getLocalType(trivial->index) != influencedGet->type) { + canOptimizeToTrivial = false; + } + } else { + canOptimizeToTrivial = false; + break; + } + } + if (canOptimizeToTrivial) { + // worth it for this copy, do it + for (auto* influencedGet : copyInfluences) { + influencedGet->index = trivial->index; + } + optimizedToTrivial[copy] = trivial; + // note that we don't + } + } + } + } + } + if (!optimizedToCopy.empty() || !optimizedToTrivial.empty()) { + // finally, we need to verify that the changes work properly, that is, + // they use the value from the right place (and are not affected by + // another set of the index we changed to). + // if one does not work, we need to undo all its siblings (don't extend + // the live range unless we are definitely removing a conflict, same + // logic as before). + LocalGraph postGraph(func); + postGraph.computeInfluences(); + for (auto& pair : optimizedToCopy) { + auto* copy = pair.first; + auto* trivial = pair.second; + auto& trivialInfluences = preGraph.setInfluences[trivial]; + for (auto* influencedGet : trivialInfluences) { + // verify the set + auto& sets = postGraph.getSetses[influencedGet]; + if (sets.size() != 1 || *sets.begin() != copy) { + // not good, undo all the changes for this copy + for (auto* undo : trivialInfluences) { + undo->index = trivial->index; + } + break; + } + } + } + for (auto& pair : optimizedToTrivial) { + auto* copy = pair.first; + auto* trivial = pair.second; + auto& copyInfluences = preGraph.setInfluences[copy]; + for (auto* influencedGet : copyInfluences) { + // verify the set + auto& sets = postGraph.getSetses[influencedGet]; + if (sets.size() != 1 || *sets.begin() != trivial) { + // not good, undo all the changes for this copy + for (auto* undo : copyInfluences) { + undo->index = copy->index; + } + break; + } + } + // if this change was ok, we can probably remove the copy itself, + // but we leave that for other passes + } + } + // remove the trivial sets + for (auto* copy : copies) { + copy->value = copy->value->cast()->value; + } + } +}; + +Pass* createMergeLocalsPass() { return new MergeLocals(); } + +} // namespace wasm diff --git a/binaryen/src/passes/Metrics.cpp b/binaryen/src/passes/Metrics.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/passes/Metrics.cpp @@ -0,0 +1,206 @@ +/* + * Copyright 2016 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include +#include +#include +#include + +using namespace std; + +namespace wasm { + +typedef map Counts; + +static Counts lastCounts; + +// Prints metrics between optimization passes. +struct Metrics + : public WalkerPass>> { + bool modifiesBinaryenIR() override { return false; } + + bool byFunction; + + Counts counts; + + Metrics(bool byFunction) : byFunction(byFunction) {} + + void visitExpression(Expression* curr) { + auto name = getExpressionName(curr); + counts[name]++; + } + + void doWalkModule(Module* module) { + ImportInfo imports(*module); + + // global things + for (auto& curr : module->exports) { + visitExport(curr.get()); + } + ModuleUtils::iterDefinedGlobals(*module, + [&](Global* curr) { walkGlobal(curr); }); + walkTable(&module->table); + walkMemory(&module->memory); + + // add imports / funcs / globals/ exports + counts["[imports]"] = imports.getNumImports(); + counts["[funcs]"] = imports.getNumDefinedFunctions(); + counts["[globals]"] = imports.getNumDefinedGlobals(); + counts["[events]"] = imports.getNumDefinedEvents(); + counts["[exports]"] = module->exports.size(); + // add memory and table + if (module->memory.exists) { + Index size = 0; + for (auto& segment : module->memory.segments) { + size += segment.data.size(); + } + counts["[memory-data]"] = size; + } + if (module->table.exists) { + Index size = 0; + for (auto& segment : module->table.segments) { + size += segment.data.size(); + } + counts["[table-data]"] = size; + } + + if (byFunction) { + // print global + printCounts("global"); + // compute binary info, so we know function sizes + BufferWithRandomAccess buffer; + WasmBinaryWriter writer(module, buffer); + writer.write(); + // print for each function + Index binaryIndex = 0; + ModuleUtils::iterDefinedFunctions(*module, [&](Function* func) { + counts.clear(); + walkFunction(func); + counts["[vars]"] = func->getNumVars(); + counts["[binary-bytes]"] = + writer.tableOfContents.functionBodies[binaryIndex++].size; + printCounts(std::string("func: ") + func->name.str); + }); + // print for each export how much code size is due to it, i.e., + // how much the module could shrink without it. + auto sizeAfterGlobalCleanup = [](Module* module) { + PassRunner runner(module, + PassOptions::getWithDefaultOptimizationOptions()); + runner.setIsNested(true); + runner.addDefaultGlobalOptimizationPostPasses(); // remove stuff + runner.run(); + BufferWithRandomAccess buffer; + WasmBinaryWriter writer(module, buffer); + writer.write(); + return buffer.size(); + }; + size_t baseline; + { + Module test; + ModuleUtils::copyModule(*module, test); + baseline = sizeAfterGlobalCleanup(&test); + } + for (auto& exp : module->exports) { + // create a test module where we remove the export and then see how much + // can be removed thanks to that + Module test; + ModuleUtils::copyModule(*module, test); + test.removeExport(exp->name); + counts.clear(); + counts["[removable-bytes-without-it]"] = + baseline - sizeAfterGlobalCleanup(&test); + printCounts(std::string("export: ") + exp->name.str + " (" + + exp->value.str + ')'); + } + // check how much size depends on the start method + if (!module->start.isNull()) { + Module test; + ModuleUtils::copyModule(*module, test); + test.start = Name(); + counts.clear(); + counts["[removable-bytes-without-it]"] = + baseline - sizeAfterGlobalCleanup(&test); + printCounts(std::string("start: ") + module->start.str); + } + // can't compare detailed info between passes yet + lastCounts.clear(); + } else { + // add function info + size_t vars = 0; + ModuleUtils::iterDefinedFunctions(*module, [&](Function* func) { + walkFunction(func); + vars += func->getNumVars(); + }); + counts["[vars]"] = vars; + // print + printCounts("total"); + // compare to next time + lastCounts = counts; + } + } + + void printCounts(std::string title) { + ostream& o = cout; + vector keys; + // add total + int total = 0; + for (auto i : counts) { + keys.push_back(i.first); + // total is of all the normal stuff, not the special [things] + if (i.first[0] != '[') { + total += i.second; + } + } + keys.push_back("[total]"); + counts["[total]"] = total; + // sort + sort(keys.begin(), keys.end(), [](const char* a, const char* b) -> bool { + return strcmp(b, a) > 0; + }); + o << title << "\n"; + for (auto* key : keys) { + auto value = counts[key]; + if (value == 0 && key[0] != '[') { + continue; + } + o << " " << left << setw(15) << key << ": " << setw(8) << value; + if (lastCounts.count(key)) { + int before = lastCounts[key]; + int after = value; + if (after - before) { + if (after > before) { + Colors::red(o); + } else { + Colors::green(o); + } + o << right << setw(8); + o << showpos << after - before << noshowpos; + Colors::normal(o); + } + } + o << "\n"; + } + } +}; + +Pass* createMetricsPass() { return new Metrics(false); } + +Pass* createFunctionMetricsPass() { return new Metrics(true); } + +} // namespace wasm diff --git a/binaryen/src/passes/MinifyImportsAndExports.cpp b/binaryen/src/passes/MinifyImportsAndExports.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/passes/MinifyImportsAndExports.cpp @@ -0,0 +1,219 @@ +/* + * Copyright 2018 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// Minifies import and export names, renaming them to short versions, +// and prints out a mapping to the new short versions. That mapping +// can then be used to minify the JS calling the wasm, together enabling +// minification of the identifiers on the JS/wasm boundary. +// +// For example, this may minify +// (import "env" "longname" (func $internal)) +// to +// (import "env" "a" (func $internal)) +// "a" is the minified name. If we also minify module names, then the +// result could be +// (import "a" "a" (func $internal)) +// +// TODO: check if we can minify names to the empty string "", which is even +// shorter than one character. + +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +namespace wasm { + +struct MinifyImportsAndExports : public Pass { + bool minifyExports, minifyModules; + +public: + explicit MinifyImportsAndExports(bool minifyExports, bool minifyModules) + : minifyExports(minifyExports), minifyModules(minifyModules) {} + +private: + // Generates minified names that are valid in JS. + // Names are computed lazily. + class MinifiedNames { + public: + MinifiedNames() { + // Reserved words in JS up to size 4 - size 5 and above would mean we use + // an astronomical number of symbols, which is not realistic anyhow. + reserved.insert("do"); + reserved.insert("if"); + reserved.insert("in"); + reserved.insert("for"); + reserved.insert("new"); + reserved.insert("try"); + reserved.insert("var"); + reserved.insert("env"); + reserved.insert("let"); + reserved.insert("case"); + reserved.insert("else"); + reserved.insert("enum"); + reserved.insert("void"); + reserved.insert("this"); + reserved.insert("with"); + + validInitialChars = + "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_$"; + validLaterChars = validInitialChars + "0123456789"; + + minifiedState.push_back(0); + } + + // Get the n-th minified name. + std::string getName(size_t n) { + ensure(n + 1); + return names[n]; + } + + private: + // Reserved words we must not emit. + std::unordered_set reserved; + + // Possible initial letters. + std::string validInitialChars; + + // Possible later letters. + std::string validLaterChars; + + // The minified names we computed so far. + std::vector names; + + // Helper state for progressively computing more minified names - + // a stack of the current index. + std::vector minifiedState; + + // Make sure we have at least n minified names. + void ensure(size_t n) { + while (names.size() < n) { + // Generate the current name. + std::string name; + auto index = minifiedState[0]; + assert(index < validInitialChars.size()); + name += validInitialChars[index]; + for (size_t i = 1; i < minifiedState.size(); i++) { + auto index = minifiedState[i]; + assert(index < validLaterChars.size()); + name += validLaterChars[index]; + } + if (reserved.count(name) == 0) { + names.push_back(name); + } + // Increment the state. + size_t i = 0; + while (1) { + minifiedState[i]++; + if (minifiedState[i] < + (i == 0 ? validInitialChars : validLaterChars).size()) { + break; + } + // Overflow. + minifiedState[i] = 0; + i++; + if (i == minifiedState.size()) { + // will become 0 after increment in next loop head + minifiedState.push_back(-1); + } + } + } + } + }; + + void run(PassRunner* runner, Module* module) override { + // Minify the imported names. + MinifiedNames names; + size_t soFar = 0; + std::map oldToNew; + std::map newToOld; + auto process = [&](Name& name) { + auto iter = oldToNew.find(name); + if (iter == oldToNew.end()) { + auto newName = names.getName(soFar++); + oldToNew[name] = newName; + newToOld[newName] = name; + name = newName; + } else { + name = iter->second; + } + }; + ModuleUtils::iterImports(*module, [&](Importable* curr) { + // Minify all import base names if we are importing modules (which means + // we will minify all modules names, so we are not being careful). + // Otherwise, assume we just want to minify "normal" imports like env + // and wasi, but not special things like asm2wasm or custom user things. + if (minifyModules || curr->module == ENV || + curr->module.startsWith("wasi_")) { + process(curr->base); + } + }); + + if (minifyExports) { + // Minify the exported names. + for (auto& curr : module->exports) { + process(curr->name); + } + } + module->updateMaps(); + // Emit the mapping. + for (auto& pair : newToOld) { + std::cout << pair.second.str << " => " << pair.first.str << '\n'; + } + + if (minifyModules) { + doMinifyModules(module); + } + } + + const Name SINGLETON_MODULE_NAME = "a"; + + void doMinifyModules(Module* module) { + // Minify the module name itself, and also merge all the modules into + // one. Assert against overlapping names. +#ifndef NDEBUG + std::set seenImports; +#endif + ModuleUtils::iterImports(*module, [&](Importable* curr) { + curr->module = SINGLETON_MODULE_NAME; +#ifndef NDEBUG + assert(seenImports.count(curr->base) == 0); + seenImports.insert(curr->base); +#endif + }); + } +}; + +Pass* createMinifyImportsPass() { + return new MinifyImportsAndExports(false, false); +} + +Pass* createMinifyImportsAndExportsPass() { + return new MinifyImportsAndExports(true, false); +} + +Pass* createMinifyImportsAndExportsAndModulesPass() { + return new MinifyImportsAndExports(true, true); +} + +} // namespace wasm diff --git a/binaryen/src/passes/NameList.cpp b/binaryen/src/passes/NameList.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/passes/NameList.cpp @@ -0,0 +1,39 @@ +/* + * Copyright 2016 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// Write out the name list of the module, similar to `nm`. +// + +#include "ir/module-utils.h" +#include "ir/utils.h" +#include "pass.h" +#include "wasm.h" + +namespace wasm { + +struct NameList : public Pass { + void run(PassRunner* runner, Module* module) override { + ModuleUtils::iterDefinedFunctions(*module, [&](Function* func) { + std::cout << " " << func->name << " : " + << Measurer::measure(func->body) << '\n'; + }); + } +}; + +Pass* createNameListPass() { return new NameList(); } + +} // namespace wasm diff --git a/binaryen/src/passes/NoExitRuntime.cpp b/binaryen/src/passes/NoExitRuntime.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/passes/NoExitRuntime.cpp @@ -0,0 +1,67 @@ +/* + * Copyright 2016 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// Assumes the program will never exit the runtime (as in the emscripten +// NO_EXIT_RUNTIME option). That means that atexit()s do not need to be +// run. +// + +#include +#include +#include +#include + +using namespace std; + +namespace wasm { + +struct NoExitRuntime : public WalkerPass> { + bool isFunctionParallel() override { return true; } + + Pass* create() override { return new NoExitRuntime; } + + // Remove all possible manifestations of atexit, across asm2wasm and llvm wasm + // backend. + std::array ATEXIT_NAMES = { + {"___cxa_atexit", "__cxa_atexit", "_atexit", "atexit"}}; + + void visitCall(Call* curr) { + auto* import = getModule()->getFunctionOrNull(curr->target); + if (!import || !import->imported() || import->module != ENV) { + return; + } + for (auto name : ATEXIT_NAMES) { + if (name == import->base) { + // Remove the call, and drop the arguments (which may have side + // effects); let other passes clean that up more. + Builder builder(*getModule()); + std::vector args; + for (auto* operand : curr->operands) { + args.push_back(builder.makeDrop(operand)); + } + // Ensure the block has the right type using the last arg. + args.push_back(builder.replaceWithIdenticalType(curr)); + replaceCurrent(builder.makeBlock(args)); + break; + } + } + } +}; + +Pass* createNoExitRuntimePass() { return new NoExitRuntime(); } + +} // namespace wasm diff --git a/binaryen/src/passes/OptimizeAddedConstants.cpp b/binaryen/src/passes/OptimizeAddedConstants.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/passes/OptimizeAddedConstants.cpp @@ -0,0 +1,410 @@ +/* + * Copyright 2019 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// Optimize added constants into load/store offsets. This requires the +// assumption that low memory is unused, so that we can replace an add (which +// might wrap) with a load/store offset (which does not). +// +// The propagate option also propagates offsets across set/get local pairs. +// +// Optimizing constants into load/store offsets is almost always +// beneficial for speed, as VMs can optimize these operations better. +// If a LocalGraph is provided, this can also propagate values along get/set +// pairs. In such a case, we may increase code size slightly or reduce +// compressibility (e.g., replace (load (get $x)) with (load offset=Z (get $y)), +// where Z is big enough to not fit in a single byte), but this is good for +// speed, and may lead to code size reductions elsewhere by using fewer locals. +// + +#include +#include +#include +#include +#include +#include + +namespace wasm { + +template class MemoryAccessOptimizer { +public: + MemoryAccessOptimizer(P* parent, + T* curr, + Module* module, + LocalGraph* localGraph) + : parent(parent), curr(curr), module(module), localGraph(localGraph) {} + + // Tries to optimize, and returns whether we propagated a change. + bool optimize() { + // The pointer itself may be a constant, if e.g. it was precomputed or + // a get that we propagated. + if (curr->ptr->template is()) { + optimizeConstantPointer(); + return false; + } + if (auto* add = curr->ptr->template dynCast()) { + if (add->op == AddInt32) { + // Look for a constant on both sides. + if (tryToOptimizeConstant(add->right, add->left) || + tryToOptimizeConstant(add->left, add->right)) { + return false; + } + } + } + if (localGraph) { + // A final important case is a propagated add: + // + // x = y + 10 + // .. + // load(x) + // => + // x = y + 10 + // .. + // load(y, offset=10) + // + // This is only valid if y does not change in the middle! + if (auto* get = curr->ptr->template dynCast()) { + auto& sets = localGraph->getSetses[get]; + if (sets.size() == 1) { + auto* set = *sets.begin(); + // May be a zero-init (in which case, we can ignore it). Must also be + // valid to propagate, as checked earlier in the parent. + if (set && parent->isPropagatable(set)) { + auto* value = set->value; + if (auto* add = value->template dynCast()) { + if (add->op == AddInt32) { + // We can optimize on either side, but only if both we find + // a constant *and* the other side cannot change in the middle. + // TODO If it could change, we may add a new local to capture + // the old value. + if (tryToOptimizePropagatedAdd( + add->right, add->left, get, set) || + tryToOptimizePropagatedAdd( + add->left, add->right, get, set)) { + return true; + } + } + } + } + } + } + } + return false; + } + +private: + P* parent; + T* curr; + Module* module; + LocalGraph* localGraph; + + void optimizeConstantPointer() { + // The constant and an offset are interchangeable: + // (load (const X)) <=> (load offset=X (const 0)) + // It may not matter if we do this or not - it's the same size, + // and in both cases the compiler can see it's a constant location. + // For code clarity and compressibility, we prefer to put the + // entire address in the constant. + if (curr->offset) { + // Note that the offset may already be larger than low memory - the + // code may know that is valid, even if we can't. Only handle the + // obviously valid case where an overflow can't occur. + auto* c = curr->ptr->template cast(); + uint32_t base = c->value.geti32(); + uint32_t offset = curr->offset; + if (uint64_t(base) + uint64_t(offset) < (uint64_t(1) << 32)) { + c->value = c->value.add(Literal(uint32_t(curr->offset))); + curr->offset = 0; + } + } + } + + struct Result { + bool succeeded; + Address total; + Result() : succeeded(false) {} + Result(Address total) : succeeded(true), total(total) {} + }; + + // See if we can optimize an offset from an expression. If we report + // success, the returned offset can be added as a replacement for the + // expression here. + bool tryToOptimizeConstant(Expression* oneSide, Expression* otherSide) { + if (auto* c = oneSide->dynCast()) { + auto result = canOptimizeConstant(c->value); + if (result.succeeded) { + curr->offset = result.total; + curr->ptr = otherSide; + if (curr->ptr->template is()) { + optimizeConstantPointer(); + } + return true; + } + } + return false; + } + + bool tryToOptimizePropagatedAdd(Expression* oneSide, + Expression* otherSide, + LocalGet* ptr, + LocalSet* set) { + if (auto* c = oneSide->dynCast()) { + if (otherSide->is()) { + // Both sides are constant - this is not optimized code, ignore. + return false; + } + auto result = canOptimizeConstant(c->value); + if (result.succeeded) { + // Looks good, but we need to make sure the other side cannot change: + // + // x = y + 10 + // y = y + 1 + // load(x) + // + // This example should not be optimized into + // + // load(x, offset=10) + // + // If the other side is a get, we may be able to prove that we can just + // use that same local, if both it and the pointer are in SSA form. In + // that case, + // + // y = .. // single assignment that dominates all uses + // x = y + 10 // single assignment that dominates all uses + // [..] + // load(x) => load(y, offset=10) + // + // This is valid since dominance is transitive, so y's definition + // dominates the load, and it is ok to replace x with y + 10 there. + Index index = -1; + bool canReuseIndex = false; + if (auto* get = otherSide->dynCast()) { + if (localGraph->isSSA(get->index) && localGraph->isSSA(ptr->index)) { + index = get->index; + canReuseIndex = true; + } + } + // If we can't reuse the index, then create a new one, + // + // x = y + 10 + // y = y + 1 + // load(x) + // => + // y' = y + // x = y' + 10 + // y = y + 1 + // load(y', offset=10) + // + // Often x has no other uses and later passes can remove it. + if (!canReuseIndex) { + index = parent->getHelperIndex(set); + } + curr->offset = result.total; + curr->ptr = Builder(*module).makeLocalGet(index, Type::i32); + return true; + } + } + return false; + } + + // Sees if we can optimize a particular constant. + Result canOptimizeConstant(Literal literal) { + auto value = literal.geti32(); + // Avoid uninteresting corner cases with peculiar offsets. + if (value >= 0 && value < PassOptions::LowMemoryBound) { + // The total offset must not allow reaching reasonable memory + // by overflowing. + auto total = curr->offset + value; + if (total < PassOptions::LowMemoryBound) { + return Result(total); + } + } + return Result(); + } +}; + +struct OptimizeAddedConstants + : public WalkerPass< + PostWalker>> { + bool isFunctionParallel() override { return true; } + + bool propagate; + + OptimizeAddedConstants(bool propagate) : propagate(propagate) {} + + Pass* create() override { return new OptimizeAddedConstants(propagate); } + + void visitLoad(Load* curr) { + MemoryAccessOptimizer optimizer( + this, curr, getModule(), localGraph.get()); + if (optimizer.optimize()) { + propagated = true; + } + } + + void visitStore(Store* curr) { + MemoryAccessOptimizer optimizer( + this, curr, getModule(), localGraph.get()); + if (optimizer.optimize()) { + propagated = true; + } + } + + void doWalkFunction(Function* func) { + // This pass is only valid under the assumption of unused low memory. + assert(getPassOptions().lowMemoryUnused); + // Multiple passes may be needed if we have x + 4 + 8 etc. (nested structs + // in C can cause this, but it's rare). Note that we only need that for the + // propagation case (as 4 + 8 would be optimized directly if it were + // adjacent). + while (1) { + propagated = false; + helperIndexes.clear(); + propagatable.clear(); + if (propagate) { + localGraph = make_unique(func); + localGraph->computeInfluences(); + localGraph->computeSSAIndexes(); + findPropagatable(); + } + super::doWalkFunction(func); + if (!helperIndexes.empty()) { + createHelperIndexes(); + } + if (propagated) { + cleanUpAfterPropagation(); + } else { + return; + } + } + } + + // For a given expression, store it to a local and return us the local index + // we can use, in order to get that value someplace else. We are provided not + // the expression, but the set in which it is in, as the arm of an add that is + // the set's value (the other arm is a constant, and we are not a constant). + // We cache these, that is, use a single one for all requests. + Index getHelperIndex(LocalSet* set) { + auto iter = helperIndexes.find(set); + if (iter != helperIndexes.end()) { + return iter->second; + } + return helperIndexes[set] = + Builder(*getModule()).addVar(getFunction(), Type::i32); + } + + bool isPropagatable(LocalSet* set) { return propagatable.count(set); } + +private: + bool propagated; + + std::unique_ptr localGraph; + + // Whether a set is propagatable. + std::set propagatable; + + void findPropagatable() { + // Conservatively, only propagate if all uses can be removed of the + // original. That is, + // x = a + 10 + // f(x) + // g(x) + // should be optimized to + // f(a, offset=10) + // g(a, offset=10) + // but if x has other uses, then avoid doing so - we'll be doing that add + // anyhow, so the load/store offset trick won't actually help. + Parents parents(getFunction()->body); + for (auto& pair : localGraph->locations) { + auto* location = pair.first; + if (auto* set = location->dynCast()) { + if (auto* add = set->value->dynCast()) { + if (add->op == AddInt32) { + if (add->left->is() || add->right->is()) { + // Looks like this might be relevant, check all uses. + bool canPropagate = true; + for (auto* get : localGraph->setInfluences[set]) { + auto* parent = parents.getParent(get); + // if this is at the top level, it's the whole body - no set can + // exist! + assert(parent); + if (!(parent->is() || parent->is())) { + canPropagate = false; + break; + } + } + if (canPropagate) { + propagatable.insert(set); + } + } + } + } + } + } + } + + void cleanUpAfterPropagation() { + // Remove sets that no longer have uses. This allows further propagation by + // letting us see the accurate amount of uses of each set. + UnneededSetRemover remover( + getFunction(), getPassOptions(), getModule()->features); + } + + std::map helperIndexes; + + void createHelperIndexes() { + struct Creator : public PostWalker { + std::map& helperIndexes; + Module* module; + + Creator(std::map& helperIndexes) + : helperIndexes(helperIndexes) {} + + void visitLocalSet(LocalSet* curr) { + auto iter = helperIndexes.find(curr); + if (iter != helperIndexes.end()) { + auto index = iter->second; + auto* binary = curr->value->cast(); + Expression** target; + if (binary->left->is()) { + target = &binary->right; + } else { + assert(binary->right->is()); + target = &binary->left; + } + auto* value = *target; + Builder builder(*module); + *target = builder.makeLocalGet(index, Type::i32); + replaceCurrent( + builder.makeSequence(builder.makeLocalSet(index, value), curr)); + } + } + } creator(helperIndexes); + creator.module = getModule(); + creator.walk(getFunction()->body); + } +}; + +Pass* createOptimizeAddedConstantsPass() { + return new OptimizeAddedConstants(false); +} + +Pass* createOptimizeAddedConstantsPropagatePass() { + return new OptimizeAddedConstants(true); +} + +} // namespace wasm diff --git a/binaryen/src/passes/OptimizeInstructions.cpp b/binaryen/src/passes/OptimizeInstructions.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/passes/OptimizeInstructions.cpp @@ -0,0 +1,1956 @@ +/* + * Copyright 2016 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// Optimize combinations of instructions +// + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// TODO: Use the new sign-extension opcodes where appropriate. This needs to be +// conditionalized on the availability of atomics. + +namespace wasm { + +Name I32_EXPR = "i32.expr"; +Name I64_EXPR = "i64.expr"; +Name F32_EXPR = "f32.expr"; +Name F64_EXPR = "f64.expr"; +Name ANY_EXPR = "any.expr"; + +// Useful information about locals +struct LocalInfo { + static const Index kUnknown = Index(-1); + + Index maxBits; + Index signExtedBits; +}; + +struct LocalScanner : PostWalker { + std::vector& localInfo; + const PassOptions& passOptions; + + LocalScanner(std::vector& localInfo, + const PassOptions& passOptions) + : localInfo(localInfo), passOptions(passOptions) {} + + void doWalkFunction(Function* func) { + // prepare + localInfo.resize(func->getNumLocals()); + for (Index i = 0; i < func->getNumLocals(); i++) { + auto& info = localInfo[i]; + if (func->isParam(i)) { + info.maxBits = getBitsForType(func->getLocalType(i)); // worst-case + info.signExtedBits = LocalInfo::kUnknown; // we will never know anything + } else { + info.maxBits = info.signExtedBits = 0; // we are open to learning + } + } + // walk + PostWalker::doWalkFunction(func); + // finalize + for (Index i = 0; i < func->getNumLocals(); i++) { + auto& info = localInfo[i]; + if (info.signExtedBits == LocalInfo::kUnknown) { + info.signExtedBits = 0; + } + } + } + + void visitLocalSet(LocalSet* curr) { + auto* func = getFunction(); + if (func->isParam(curr->index)) { + return; + } + auto type = getFunction()->getLocalType(curr->index); + if (type != Type::i32 && type != Type::i64) { + return; + } + // an integer var, worth processing + auto* value = Properties::getFallthrough( + curr->value, passOptions, getModule()->features); + auto& info = localInfo[curr->index]; + info.maxBits = std::max(info.maxBits, Bits::getMaxBits(value, this)); + auto signExtBits = LocalInfo::kUnknown; + if (Properties::getSignExtValue(value)) { + signExtBits = Properties::getSignExtBits(value); + } else if (auto* load = value->dynCast()) { + if (LoadUtils::isSignRelevant(load) && load->signed_) { + signExtBits = load->bytes * 8; + } + } + if (info.signExtedBits == 0) { + info.signExtedBits = signExtBits; // first info we see + } else if (info.signExtedBits != signExtBits) { + // contradictory information, give up + info.signExtedBits = LocalInfo::kUnknown; + } + } + + // define this for the templated getMaxBits method. we know nothing here yet + // about locals, so return the maxes + Index getMaxBitsForLocal(LocalGet* get) { return getBitsForType(get->type); } + + Index getBitsForType(Type type) { + TODO_SINGLE_COMPOUND(type); + switch (type.getBasic()) { + case Type::i32: + return 32; + case Type::i64: + return 64; + default: + return -1; + } + } +}; + +// Create a custom matcher for checking side effects +template struct PureMatcherKind {}; +template +struct Match::Internal::KindTypeRegistry> { + using matched_t = Expression*; + using data_t = Opt*; +}; +template struct Match::Internal::MatchSelf> { + bool operator()(Expression* curr, Opt* opt) { + return !opt->effects(curr).hasSideEffects(); + } +}; + +// Main pass class +struct OptimizeInstructions + : public WalkerPass< + PostWalker>> { + bool isFunctionParallel() override { return true; } + + Pass* create() override { return new OptimizeInstructions; } + + bool fastMath; + + void doWalkFunction(Function* func) { + fastMath = getPassOptions().fastMath; + // first, scan locals + { + LocalScanner scanner(localInfo, getPassOptions()); + scanner.setModule(getModule()); + scanner.walkFunction(func); + } + // main walk + super::doWalkFunction(func); + } + + void visitExpression(Expression* curr) { + // we may be able to apply multiple patterns, one may open opportunities + // that look deeper NB: patterns must not have cycles + while (1) { + auto* handOptimized = handOptimize(curr); + if (handOptimized) { + curr = handOptimized; + replaceCurrent(curr); + continue; + } + break; + } + } + + EffectAnalyzer effects(Expression* expr) { + return EffectAnalyzer(getPassOptions(), getModule()->features, expr); + } + + decltype(auto) pure(Expression** binder) { + using namespace Match::Internal; + return Matcher>(binder, this); + } + + bool canReorder(Expression* a, Expression* b) { + return EffectAnalyzer::canReorder( + getPassOptions(), getModule()->features, a, b); + } + + // Optimizations that don't yet fit in the pattern DSL, but could be + // eventually maybe + Expression* handOptimize(Expression* curr) { + FeatureSet features = getModule()->features; + // if this contains dead code, don't bother trying to optimize it, the type + // might change (if might not be unreachable if just one arm is, for + // example). this optimization pass focuses on actually executing code. the + // only exceptions are control flow changes + if (curr->type == Type::unreachable && !curr->is() && + !curr->is() && !curr->is()) { + return nullptr; + } + if (auto* binary = curr->dynCast()) { + if (isSymmetric(binary)) { + canonicalize(binary); + } + } + + { + // TODO: It is an ongoing project to port more transformations to the + // match API. Once most of the transformations have been ported, the + // `using namespace Match` can be hoisted to function scope and this extra + // block scope can be removed. + using namespace Match; + Builder builder(*getModule()); + { + // try to get rid of (0 - ..), that is, a zero only used to negate an + // int. an add of a subtract can be flipped in order to remove it: + // (i32.add + // (i32.sub + // (i32.const 0) + // X + // ) + // Y + // ) + // => + // (i32.sub + // Y + // X + // ) + // Note that this reorders X and Y, so we need to be careful about that. + Expression *x, *y; + Binary* sub; + if (matches(curr, + binary(AddInt32, + binary(&sub, SubInt32, i32(0), any(&x)), + any(&y))) && + canReorder(x, y)) { + sub->left = y; + sub->right = x; + return sub; + } + } + { + // The flip case is even easier, as no reordering occurs: + // (i32.add + // Y + // (i32.sub + // (i32.const 0) + // X + // ) + // ) + // => + // (i32.sub + // Y + // X + // ) + Expression* y; + Binary* sub; + if (matches(curr, + binary(AddInt32, + any(&y), + binary(&sub, SubInt32, i32(0), any())))) { + sub->left = y; + return sub; + } + } + { + // eqz((signed)x % C_pot) => eqz(x & (abs(C_pot) - 1)) + Const* c; + Binary* inner; + if (matches(curr, + unary(Abstract::EqZ, + binary(&inner, Abstract::RemS, any(), ival(&c)))) && + (c->value.isSignedMin() || + Bits::isPowerOf2(c->value.abs().getInteger()))) { + inner->op = Abstract::getBinary(c->type, Abstract::And); + if (c->value.isSignedMin()) { + c->value = Literal::makeSignedMax(c->type); + } else { + c->value = c->value.abs().sub(Literal::makeOne(c->type)); + } + return curr; + } + } + { + // try de-morgan's AND law, + // (eqz X) and (eqz Y) === eqz (X or Y) + // Note that the OR and XOR laws do not work here, as these + // are not booleans (we could check if they are, but a boolean + // would already optimize with the eqz anyhow, unless propagating). + // But for AND, the left is true iff X and Y are each all zero bits, + // and the right is true if the union of their bits is zero; same. + Unary* un; + Binary* bin; + Expression *x, *y; + if (matches(curr, + binary(&bin, + AndInt32, + unary(&un, EqZInt32, any(&x)), + unary(EqZInt32, any(&y))))) { + bin->op = OrInt32; + bin->left = x; + bin->right = y; + un->value = bin; + return un; + } + } + { + // i32.eqz(i32.wrap_i64(x)) => i64.eqz(x) + // where maxBits(x) <= 32 + Unary* inner; + Expression* x; + if (matches(curr, unary(EqZInt32, unary(&inner, WrapInt64, any(&x)))) && + Bits::getMaxBits(x, this) <= 32) { + inner->op = EqZInt64; + inner->value = x; + return inner; + } + } + { + // x <<>> (C & (31 | 63)) ==> x <<>> C' + // x <<>> (y & (31 | 63)) ==> x <<>> y + // where '<<>>': + // '<<', '>>', '>>>'. 'rotl' or 'rotr' + BinaryOp op; + Const* c; + Expression *x, *y; + + // x <<>> C + if (matches(curr, binary(&op, any(&x), ival(&c))) && + Abstract::hasAnyShift(op)) { + // truncate RHS constant to effective size as: + // i32(x) <<>> const(C & 31)) + // i64(x) <<>> const(C & 63)) + c->value = c->value.and_( + Literal::makeFromInt32(c->type.getByteSize() * 8 - 1, c->type)); + // x <<>> 0 ==> x + if (c->value.isZero()) { + return x; + } + } + if (matches( + curr, + binary(&op, any(&x), binary(Abstract::And, any(&y), ival(&c)))) && + Abstract::hasAnyShift(op)) { + // i32(x) <<>> (y & 31) ==> x <<>> y + // i64(x) <<>> (y & 63) ==> x <<>> y + if ((c->type == Type::i32 && (c->value.geti32() & 31) == 31) || + (c->type == Type::i64 && (c->value.geti64() & 63LL) == 63LL)) { + curr->cast()->right = y; + return curr; + } + } + } + } + + if (auto* select = curr->dynCast()) { + select->ifTrue = optimizeBoolean(select->ifTrue); + select->ifFalse = optimizeBoolean(select->ifFalse); + } else if (auto* tryy = boolean->dynCast()) { + if (tryy->type == Type::i32) { + tryy->body = optimizeBoolean(tryy->body); + tryy->catchBody = optimizeBoolean(tryy->catchBody); + } + } + // TODO: recurse into br values? + return boolean; + } + + Expression* optimizeSelect(Select* curr) { + using namespace Match; + Builder builder(*getModule()); + curr->condition = optimizeBoolean(curr->condition); + { + // Constant condition, we can just pick the correct side (barring side + // effects) + Expression *ifTrue, *ifFalse; + if (matches(curr, select(pure(&ifTrue), any(&ifFalse), i32(0)))) { + return ifFalse; + } + if (matches(curr, select(any(&ifTrue), any(&ifFalse), i32(0)))) { + return builder.makeSequence(builder.makeDrop(ifTrue), ifFalse); + } + int32_t cond; + if (matches(curr, select(any(&ifTrue), pure(&ifFalse), i32(&cond)))) { + // The condition must be non-zero because a zero would have matched one + // of the previous patterns. + assert(cond != 0); + return ifTrue; + } + // Don't bother when `ifFalse` isn't pure - we would need to reverse the + // order using a temp local, which would be bad + } + { + // Flip select to remove eqz if we can reorder + Select* s; + Expression *ifTrue, *ifFalse, *c; + if (matches( + curr, + select( + &s, any(&ifTrue), any(&ifFalse), unary(EqZInt32, any(&c)))) && + canReorder(ifTrue, ifFalse)) { + s->ifTrue = ifFalse; + s->ifFalse = ifTrue; + s->condition = c; + } + } + { + // Simplify selects between 0 and 1 + Expression* c; + bool reversed = matches(curr, select(ival(0), ival(1), any(&c))); + if (reversed || matches(curr, select(ival(1), ival(0), any(&c)))) { + if (reversed) { + c = optimizeBoolean(builder.makeUnary(EqZInt32, c)); + } + if (!Properties::emitsBoolean(c)) { + // cond ? 1 : 0 ==> !!cond + c = builder.makeUnary(EqZInt32, builder.makeUnary(EqZInt32, c)); + } + return curr->type == Type::i64 ? builder.makeUnary(ExtendUInt32, c) : c; + } + } + { + // Sides are identical, fold + Expression *ifTrue, *ifFalse, *c; + if (matches(curr, select(any(&ifTrue), any(&ifFalse), any(&c))) && + ExpressionAnalyzer::equal(ifTrue, ifFalse)) { + auto value = effects(ifTrue); + if (value.hasSideEffects()) { + // At best we don't need the condition, but need to execute the + // value twice. a block is larger than a select by 2 bytes, and we + // must drop one value, so 3, while we save the condition, so it's + // not clear this is worth it, TODO + } else { + // value has no side effects + auto condition = effects(c); + if (!condition.hasSideEffects()) { + return ifTrue; + } else { + // The condition is last, so we need a new local, and it may be a + // bad idea to use a block like we do for an if. Do it only if we + // can reorder + if (!condition.invalidates(value)) { + return builder.makeSequence(builder.makeDrop(c), ifTrue); + } + } + } + } + } + return nullptr; + } + + // find added constants in an expression tree, including multiplied/shifted, + // and combine them note that we ignore division/shift-right, as rounding + // makes this nonlinear, so not a valid opt + Expression* optimizeAddedConstants(Binary* binary) { + uint32_t constant = 0; + std::vector constants; + + struct SeekState { + Expression* curr; + int mul; + SeekState(Expression* curr, int mul) : curr(curr), mul(mul) {} + }; + std::vector seekStack; + seekStack.emplace_back(binary, 1); + while (!seekStack.empty()) { + auto state = seekStack.back(); + seekStack.pop_back(); + auto curr = state.curr; + auto mul = state.mul; + if (auto* c = curr->dynCast()) { + uint32_t value = c->value.geti32(); + if (value != 0) { + constant += value * mul; + constants.push_back(c); + } + continue; + } else if (auto* binary = curr->dynCast()) { + if (binary->op == AddInt32) { + seekStack.emplace_back(binary->right, mul); + seekStack.emplace_back(binary->left, mul); + continue; + } else if (binary->op == SubInt32) { + // if the left is a zero, ignore it, it's how we negate ints + auto* left = binary->left->dynCast(); + seekStack.emplace_back(binary->right, -mul); + if (!left || left->value.geti32() != 0) { + seekStack.emplace_back(binary->left, mul); + } + continue; + } else if (binary->op == ShlInt32) { + if (auto* c = binary->right->dynCast()) { + seekStack.emplace_back( + binary->left, mul * Bits::pow2(Bits::getEffectiveShifts(c))); + continue; + } + } else if (binary->op == MulInt32) { + if (auto* c = binary->left->dynCast()) { + seekStack.emplace_back(binary->right, mul * c->value.geti32()); + continue; + } else if (auto* c = binary->right->dynCast()) { + seekStack.emplace_back(binary->left, mul * c->value.geti32()); + continue; + } + } + } + }; + // find all factors + if (constants.size() <= 1) { + // nothing much to do, except for the trivial case of adding/subbing a + // zero + if (auto* c = binary->right->dynCast()) { + if (c->value.geti32() == 0) { + return binary->left; + } + } + return nullptr; + } + // wipe out all constants, we'll replace with a single added one + for (auto* c : constants) { + c->value = Literal(int32_t(0)); + } + // remove added/subbed zeros + struct ZeroRemover : public PostWalker { + // TODO: we could save the binarys and costs we drop, and reuse them later + + PassOptions& passOptions; + + ZeroRemover(PassOptions& passOptions) : passOptions(passOptions) {} + + void visitBinary(Binary* curr) { + FeatureSet features = getModule()->features; + auto* left = curr->left->dynCast(); + auto* right = curr->right->dynCast(); + if (curr->op == AddInt32) { + if (left && left->value.geti32() == 0) { + replaceCurrent(curr->right); + return; + } + if (right && right->value.geti32() == 0) { + replaceCurrent(curr->left); + return; + } + } else if (curr->op == SubInt32) { + // we must leave a left zero, as it is how we negate ints + if (right && right->value.geti32() == 0) { + replaceCurrent(curr->left); + return; + } + } else if (curr->op == ShlInt32) { + // shifting a 0 is a 0, or anything by 0 has no effect, all unless the + // shift has side effects + if (((left && left->value.geti32() == 0) || + (right && Bits::getEffectiveShifts(right) == 0)) && + !EffectAnalyzer(passOptions, features, curr->right) + .hasSideEffects()) { + replaceCurrent(curr->left); + return; + } + } else if (curr->op == MulInt32) { + // multiplying by zero is a zero, unless the other side has side + // effects + if (left && left->value.geti32() == 0 && + !EffectAnalyzer(passOptions, features, curr->right) + .hasSideEffects()) { + replaceCurrent(left); + return; + } + if (right && right->value.geti32() == 0 && + !EffectAnalyzer(passOptions, features, curr->left) + .hasSideEffects()) { + replaceCurrent(right); + return; + } + } + } + }; + Expression* walked = binary; + ZeroRemover remover(getPassOptions()); + remover.setModule(getModule()); + remover.walk(walked); + if (constant == 0) { + return walked; // nothing more to do + } + if (auto* c = walked->dynCast()) { + assert(c->value.geti32() == 0); + c->value = Literal(constant); + return c; + } + Builder builder(*getModule()); + return builder.makeBinary( + AddInt32, walked, builder.makeConst(Literal(constant))); + } + + // expensive1 | expensive2 can be turned into expensive1 ? 1 : expensive2, + // and expensive | cheap can be turned into cheap ? 1 : expensive, + // so that we can avoid one expensive computation, if it has no side effects. + Expression* conditionalizeExpensiveOnBitwise(Binary* binary) { + // this operation can increase code size, so don't always do it + auto& options = getPassRunner()->options; + if (options.optimizeLevel < 2 || options.shrinkLevel > 0) { + return nullptr; + } + const auto MIN_COST = 7; + assert(binary->op == AndInt32 || binary->op == OrInt32); + if (binary->right->is()) { + return nullptr; // trivial + } + // bitwise logical operator on two non-numerical values, check if they are + // boolean + auto* left = binary->left; + auto* right = binary->right; + if (!Properties::emitsBoolean(left) || !Properties::emitsBoolean(right)) { + return nullptr; + } + auto leftEffects = effects(left); + auto rightEffects = effects(right); + auto leftHasSideEffects = leftEffects.hasSideEffects(); + auto rightHasSideEffects = rightEffects.hasSideEffects(); + if (leftHasSideEffects && rightHasSideEffects) { + return nullptr; // both must execute + } + // canonicalize with side effects, if any, happening on the left + if (rightHasSideEffects) { + if (CostAnalyzer(left).cost < MIN_COST) { + return nullptr; // avoidable code is too cheap + } + if (leftEffects.invalidates(rightEffects)) { + return nullptr; // cannot reorder + } + std::swap(left, right); + } else if (leftHasSideEffects) { + if (CostAnalyzer(right).cost < MIN_COST) { + return nullptr; // avoidable code is too cheap + } + } else { + // no side effects, reorder based on cost estimation + auto leftCost = CostAnalyzer(left).cost; + auto rightCost = CostAnalyzer(right).cost; + if (std::max(leftCost, rightCost) < MIN_COST) { + return nullptr; // avoidable code is too cheap + } + // canonicalize with expensive code on the right + if (leftCost > rightCost) { + std::swap(left, right); + } + } + // worth it! perform conditionalization + Builder builder(*getModule()); + if (binary->op == OrInt32) { + return builder.makeIf( + left, builder.makeConst(Literal(int32_t(1))), right); + } else { // & + return builder.makeIf( + left, right, builder.makeConst(Literal(int32_t(0)))); + } + } + + // We can combine `or` operations, e.g. + // (x > y) | (x == y) ==> x >= y + Expression* combineOr(Binary* binary) { + assert(binary->op == OrInt32); + if (auto* left = binary->left->dynCast()) { + if (auto* right = binary->right->dynCast()) { + if (left->op != right->op && + ExpressionAnalyzer::equal(left->left, right->left) && + ExpressionAnalyzer::equal(left->right, right->right) && + !effects(left->left).hasSideEffects() && + !effects(left->right).hasSideEffects()) { + switch (left->op) { + // (x > y) | (x == y) ==> x >= y + case EqInt32: { + if (right->op == GtSInt32) { + left->op = GeSInt32; + return left; + } + break; + } + default: { + } + } + } + } + } + return nullptr; + } + + // fold constant factors into the offset + void optimizeMemoryAccess(Expression*& ptr, Address& offset) { + // ptr may be a const, but it isn't worth folding that in (we still have a + // const); in fact, it's better to do the opposite for gzip purposes as well + // as for readability. + auto* last = ptr->dynCast(); + if (last) { + uint64_t value64 = last->value.getInteger(); + uint64_t offset64 = offset; + if (getModule()->memory.is64()) { + last->value = Literal(int64_t(value64 + offset64)); + offset = 0; + } else { + // don't do this if it would wrap the pointer + if (value64 <= uint64_t(std::numeric_limits::max()) && + offset64 <= uint64_t(std::numeric_limits::max()) && + value64 + offset64 <= + uint64_t(std::numeric_limits::max())) { + last->value = Literal(int32_t(value64 + offset64)); + offset = 0; + } + } + } + } + + // Optimize a multiply by a power of two on the right, which + // can be a shift. + // This doesn't shrink code size, and VMs likely optimize it anyhow, + // but it's still worth doing since + // * Often shifts are more common than muls. + // * The constant is smaller. + template Expression* optimizePowerOf2Mul(Binary* binary, T c) { + static_assert(std::is_same::value || + std::is_same::value, + "type mismatch"); + auto shifts = Bits::countTrailingZeroes(c); + binary->op = std::is_same::value ? ShlInt32 : ShlInt64; + binary->right->cast()->value = Literal(static_cast(shifts)); + return binary; + } + + // Optimize an unsigned divide / remainder by a power of two on the right + // This doesn't shrink code size, and VMs likely optimize it anyhow, + // but it's still worth doing since + // * Usually ands are more common than urems. + // * The constant is slightly smaller. + template Expression* optimizePowerOf2UDiv(Binary* binary, T c) { + static_assert(std::is_same::value || + std::is_same::value, + "type mismatch"); + auto shifts = Bits::countTrailingZeroes(c); + binary->op = std::is_same::value ? ShrUInt32 : ShrUInt64; + binary->right->cast()->value = Literal(static_cast(shifts)); + return binary; + } + + template Expression* optimizePowerOf2URem(Binary* binary, T c) { + static_assert(std::is_same::value || + std::is_same::value, + "type mismatch"); + binary->op = std::is_same::value ? AndInt32 : AndInt64; + binary->right->cast()->value = Literal(c - 1); + return binary; + } + + Expression* makeZeroExt(Expression* curr, int32_t bits) { + Builder builder(*getModule()); + return builder.makeBinary( + AndInt32, curr, builder.makeConst(Literal(Bits::lowBitMask(bits)))); + } + + // given an "almost" sign extend - either a proper one, or it + // has too many shifts left - we remove the sign extend. If there are + // too many shifts, we split the shifts first, so this removes the + // two sign extend shifts and adds one (smaller one) + Expression* removeAlmostSignExt(Binary* outer) { + auto* inner = outer->left->cast(); + auto* outerConst = outer->right->cast(); + auto* innerConst = inner->right->cast(); + auto* value = inner->left; + if (outerConst->value == innerConst->value) { + return value; + } + // add a shift, by reusing the existing node + innerConst->value = innerConst->value.sub(outerConst->value); + return inner; + } + + // check if an expression is already sign-extended + bool isSignExted(Expression* curr, Index bits) { + if (Properties::getSignExtValue(curr)) { + return Properties::getSignExtBits(curr) == bits; + } + if (auto* get = curr->dynCast()) { + // check what we know about the local + return localInfo[get->index].signExtedBits == bits; + } + return false; + } + + // optimize trivial math operations, given that the right side of a binary + // is a constant + Expression* optimizeWithConstantOnRight(Binary* curr) { + using namespace Match; + Builder builder(*getModule()); + Expression* left; + auto* right = curr->right->cast(); + auto type = curr->right->type; + + // Operations on zero + if (matches(curr, binary(Abstract::Shl, any(&left), ival(0))) || + matches(curr, binary(Abstract::ShrU, any(&left), ival(0))) || + matches(curr, binary(Abstract::ShrS, any(&left), ival(0))) || + matches(curr, binary(Abstract::Or, any(&left), ival(0))) || + matches(curr, binary(Abstract::Xor, any(&left), ival(0)))) { + return left; + } + if (matches(curr, binary(Abstract::Mul, pure(&left), ival(0))) || + matches(curr, binary(Abstract::And, pure(&left), ival(0)))) { + return right; + } + // x == 0 ==> eqz x + if (matches(curr, binary(Abstract::Eq, any(&left), ival(0)))) { + return builder.makeUnary(Abstract::getUnary(type, Abstract::EqZ), left); + } + // Operations on one + // (signed)x % 1 ==> 0 + if (matches(curr, binary(Abstract::RemS, pure(&left), ival(1)))) { + right->value = Literal::makeZero(type); + return right; + } + // (signed)x % C_pot != 0 ==> (x & (abs(C_pot) - 1)) != 0 + { + Const* c; + Binary* inner; + if (matches(curr, + binary(Abstract::Ne, + binary(&inner, Abstract::RemS, any(), ival(&c)), + ival(0))) && + (c->value.isSignedMin() || + Bits::isPowerOf2(c->value.abs().getInteger()))) { + inner->op = Abstract::getBinary(c->type, Abstract::And); + if (c->value.isSignedMin()) { + c->value = Literal::makeSignedMax(c->type); + } else { + c->value = c->value.abs().sub(Literal::makeOne(c->type)); + } + return curr; + } + } + // bool(x) | 1 ==> 1 + if (matches(curr, binary(Abstract::Or, pure(&left), ival(1))) && + Bits::getMaxBits(left, this) == 1) { + return right; + } + // bool(x) & 1 ==> bool(x) + if (matches(curr, binary(Abstract::And, any(&left), ival(1))) && + Bits::getMaxBits(left, this) == 1) { + return left; + } + // bool(x) == 1 ==> bool(x) + if (matches(curr, binary(EqInt32, any(&left), i32(1))) && + Bits::getMaxBits(left, this) == 1) { + return left; + } + // i64(bool(x)) == 1 ==> i32(bool(x)) + // i64(bool(x)) != 0 ==> i32(bool(x)) + if ((matches(curr, binary(EqInt64, any(&left), i64(1))) || + matches(curr, binary(NeInt64, any(&left), i64(0)))) && + Bits::getMaxBits(left, this) == 1) { + return builder.makeUnary(WrapInt64, left); + } + // bool(x) != 1 ==> !bool(x) + if (matches(curr, binary(Abstract::Ne, any(&left), ival(1))) && + Bits::getMaxBits(curr->left, this) == 1) { + return builder.makeUnary(Abstract::getUnary(type, Abstract::EqZ), left); + } + + // Operations on all 1s + // x & -1 ==> x + if (matches(curr, binary(Abstract::And, any(&left), ival(-1)))) { + return left; + } + // x | -1 ==> -1 + if (matches(curr, binary(Abstract::Or, pure(&left), ival(-1)))) { + return right; + } + // (signed)x % -1 ==> 0 + if (matches(curr, binary(Abstract::RemS, pure(&left), ival(-1)))) { + right->value = Literal::makeZero(type); + return right; + } + // (unsigned)x > -1 ==> 0 + if (matches(curr, binary(Abstract::GtU, pure(&left), ival(-1)))) { + right->value = Literal::makeZero(Type::i32); + right->type = Type::i32; + return right; + } + // (unsigned)x < -1 ==> x != -1 + // Friendlier to JS emitting as we don't need to write an unsigned -1 value + // which is large. + if (matches(curr, binary(Abstract::LtU, any(), ival(-1)))) { + curr->op = Abstract::getBinary(type, Abstract::Ne); + return curr; + } + // x * -1 ==> 0 - x + if (matches(curr, binary(Abstract::Mul, any(&left), ival(-1)))) { + right->value = Literal::makeZero(type); + curr->op = Abstract::getBinary(type, Abstract::Sub); + curr->left = right; + curr->right = left; + return curr; + } + // (unsigned)x <= -1 ==> 1 + if (matches(curr, binary(Abstract::LeU, pure(&left), ival(-1)))) { + right->value = Literal::makeOne(Type::i32); + right->type = Type::i32; + return right; + } + { + // ~(1 << x) aka (1 << x) ^ -1 ==> rotl(-2, x) + Expression* x; + if (matches(curr, + binary(Abstract::Xor, + binary(Abstract::Shl, ival(1), any(&x)), + ival(-1)))) { + curr->op = Abstract::getBinary(type, Abstract::RotL); + right->value = Literal::makeFromInt32(-2, type); + curr->left = right; + curr->right = x; + return curr; + } + } + { + // Wasm binary encoding uses signed LEBs, which slightly favor negative + // numbers: -64 is more efficient than +64 etc., as well as other powers + // of two 7 bits etc. higher. we therefore prefer x - -64 over x + 64. in + // theory we could just prefer negative numbers over positive, but that + // can have bad effects on gzip compression (as it would mean more + // subtractions than the more common additions). TODO: Simplify this by + // adding an ival matcher than can bind int64_t vars. + int64_t value; + if ((matches(curr, binary(Abstract::Add, any(), ival(&value))) || + matches(curr, binary(Abstract::Sub, any(), ival(&value)))) && + (value == 0x40 || value == 0x2000 || value == 0x100000 || + value == 0x8000000 || value == 0x400000000LL || + value == 0x20000000000LL || value == 0x1000000000000LL || + value == 0x80000000000000LL || value == 0x4000000000000000LL)) { + right->value = right->value.neg(); + if (matches(curr, binary(Abstract::Add, any(), constant()))) { + curr->op = Abstract::getBinary(type, Abstract::Sub); + } else { + curr->op = Abstract::getBinary(type, Abstract::Add); + } + return curr; + } + } + { + double value; + if (matches(curr, binary(Abstract::Sub, any(), fval(&value))) && + value == 0.0) { + // x - (-0.0) ==> x + 0.0 + if (std::signbit(value)) { + curr->op = Abstract::getBinary(type, Abstract::Add); + right->value = right->value.neg(); + return curr; + } else if (fastMath) { + // x - 0.0 ==> x + return curr->left; + } + } + } + { + // x + (-0.0) ==> x + double value; + if (fastMath && + matches(curr, binary(Abstract::Add, any(), fval(&value))) && + value == 0.0 && std::signbit(value)) { + return curr->left; + } + } + // x * -1.0 ==> -x + if (fastMath && matches(curr, binary(Abstract::Mul, any(), fval(-1.0)))) { + return builder.makeUnary(Abstract::getUnary(type, Abstract::Neg), left); + } + if (matches(curr, binary(Abstract::Mul, any(&left), constant(1))) || + matches(curr, binary(Abstract::DivS, any(&left), constant(1))) || + matches(curr, binary(Abstract::DivU, any(&left), constant(1)))) { + if (curr->type.isInteger() || fastMath) { + return left; + } + } + return nullptr; + } + + // optimize trivial math operations, given that the left side of a binary + // is a constant. since we canonicalize constants to the right for symmetrical + // operations, we only need to handle asymmetrical ones here + // TODO: templatize on type? + Expression* optimizeWithConstantOnLeft(Binary* binary) { + auto type = binary->left->type; + auto* left = binary->left->cast(); + if (type.isInteger()) { + // operations on zero + if (left->value == Literal::makeFromInt32(0, type)) { + if ((binary->op == Abstract::getBinary(type, Abstract::Shl) || + binary->op == Abstract::getBinary(type, Abstract::ShrU) || + binary->op == Abstract::getBinary(type, Abstract::ShrS)) && + !effects(binary->right).hasSideEffects()) { + return binary->left; + } + } + } + return nullptr; + } + + // TODO: templatize on type? + Expression* optimizeRelational(Binary* binary) { + // TODO: inequalities can also work, if the constants do not overflow + auto type = binary->right->type; + // integer math, even on 2s complement, allows stuff like + // x + 5 == 7 + // => + // x == 2 + if (binary->left->type.isInteger()) { + if (binary->op == Abstract::getBinary(type, Abstract::Eq) || + binary->op == Abstract::getBinary(type, Abstract::Ne)) { + if (auto* left = binary->left->dynCast()) { + if (left->op == Abstract::getBinary(type, Abstract::Add) || + left->op == Abstract::getBinary(type, Abstract::Sub)) { + if (auto* leftConst = left->right->dynCast()) { + if (auto* rightConst = binary->right->dynCast()) { + return combineRelationalConstants( + binary, left, leftConst, nullptr, rightConst); + } else if (auto* rightBinary = binary->right->dynCast()) { + if (rightBinary->op == + Abstract::getBinary(type, Abstract::Add) || + rightBinary->op == + Abstract::getBinary(type, Abstract::Sub)) { + if (auto* rightConst = rightBinary->right->dynCast()) { + return combineRelationalConstants( + binary, left, leftConst, rightBinary, rightConst); + } + } + } + } + } + } + } + } + return nullptr; + } + + Expression* deduplicateUnary(Unary* unaryOuter) { + if (auto* unaryInner = unaryOuter->value->dynCast()) { + if (unaryInner->op == unaryOuter->op) { + switch (unaryInner->op) { + case NegFloat32: + case NegFloat64: { + // neg(neg(x)) ==> x + return unaryInner->value; + } + case AbsFloat32: + case CeilFloat32: + case FloorFloat32: + case TruncFloat32: + case NearestFloat32: + case AbsFloat64: + case CeilFloat64: + case FloorFloat64: + case TruncFloat64: + case NearestFloat64: { + // unaryOp(unaryOp(x)) ==> unaryOp(x) + return unaryInner; + } + case ExtendS8Int32: + case ExtendS16Int32: { + assert(getModule()->features.hasSignExt()); + return unaryInner; + } + case EqZInt32: { + // eqz(eqz(bool(x))) ==> bool(x) + if (Bits::getMaxBits(unaryInner->value, this) == 1) { + return unaryInner->value; + } + break; + } + default: { + } + } + } + } + return nullptr; + } + + Expression* deduplicateBinary(Binary* outer) { + Type type = outer->type; + if (type.isInteger()) { + if (auto* inner = outer->right->dynCast()) { + if (outer->op == inner->op) { + if (!EffectAnalyzer( + getPassOptions(), getModule()->features, outer->left) + .hasSideEffects()) { + if (ExpressionAnalyzer::equal(inner->left, outer->left)) { + // x - (x - y) ==> y + // x ^ (x ^ y) ==> y + if (outer->op == Abstract::getBinary(type, Abstract::Sub) || + outer->op == Abstract::getBinary(type, Abstract::Xor)) { + return inner->right; + } + // x & (x & y) ==> x & y + // x | (x | y) ==> x | y + if (outer->op == Abstract::getBinary(type, Abstract::And) || + outer->op == Abstract::getBinary(type, Abstract::Or)) { + return inner; + } + } + if (ExpressionAnalyzer::equal(inner->right, outer->left) && + canReorder(outer->left, inner->left)) { + // x ^ (y ^ x) ==> y + // (note that we need the check for reordering here because if + // e.g. y writes to a local that x reads, the second appearance + // of x would be different from the first) + if (outer->op == Abstract::getBinary(type, Abstract::Xor)) { + return inner->left; + } + + // x & (y & x) ==> y & x + // x | (y | x) ==> y | x + // (here we need the check for reordering for the more obvious + // reason that previously x appeared before y, and now y appears + // first; or, if we tried to emit x [&|] y here, reversing the + // order, we'd be in the same situation as the previous comment) + if (outer->op == Abstract::getBinary(type, Abstract::And) || + outer->op == Abstract::getBinary(type, Abstract::Or)) { + return inner; + } + } + } + } + } + if (auto* inner = outer->left->dynCast()) { + if (outer->op == inner->op) { + if (!EffectAnalyzer( + getPassOptions(), getModule()->features, outer->right) + .hasSideEffects()) { + if (ExpressionAnalyzer::equal(inner->right, outer->right)) { + // (x ^ y) ^ y ==> x + if (outer->op == Abstract::getBinary(type, Abstract::Xor)) { + return inner->left; + } + // (x % y) % y ==> x % y + // (x & y) & y ==> x & y + // (x | y) | y ==> x | y + if (outer->op == Abstract::getBinary(type, Abstract::RemS) || + outer->op == Abstract::getBinary(type, Abstract::RemU) || + outer->op == Abstract::getBinary(type, Abstract::And) || + outer->op == Abstract::getBinary(type, Abstract::Or)) { + return inner; + } + } + // See comments in the parallel code earlier about ordering here. + if (ExpressionAnalyzer::equal(inner->left, outer->right) && + canReorder(inner->left, inner->right)) { + // (x ^ y) ^ x ==> y + if (outer->op == Abstract::getBinary(type, Abstract::Xor)) { + return inner->right; + } + // (x & y) & x ==> x & y + // (x | y) | x ==> x | y + if (outer->op == Abstract::getBinary(type, Abstract::And) || + outer->op == Abstract::getBinary(type, Abstract::Or)) { + return inner; + } + } + } + } + } + } + return nullptr; + } + + // given a relational binary with a const on both sides, combine the constants + // left is also a binary, and has a constant; right may be just a constant, in + // which case right is nullptr + Expression* combineRelationalConstants(Binary* binary, + Binary* left, + Const* leftConst, + Binary* right, + Const* rightConst) { + auto type = binary->right->type; + // we fold constants to the right + Literal extra = leftConst->value; + if (left->op == Abstract::getBinary(type, Abstract::Sub)) { + extra = extra.neg(); + } + if (right && right->op == Abstract::getBinary(type, Abstract::Sub)) { + extra = extra.neg(); + } + rightConst->value = rightConst->value.sub(extra); + binary->left = left->left; + return binary; + } + + Expression* optimizeMemoryCopy(MemoryCopy* memCopy) { + PassOptions options = getPassOptions(); + + if (options.ignoreImplicitTraps) { + if (ExpressionAnalyzer::equal(memCopy->dest, memCopy->source)) { + // memory.copy(x, x, sz) ==> {drop(x), drop(x), drop(sz)} + Builder builder(*getModule()); + return builder.makeBlock({builder.makeDrop(memCopy->dest), + builder.makeDrop(memCopy->source), + builder.makeDrop(memCopy->size)}); + } + } + + // memory.copy(dst, src, C) ==> store(dst, load(src)) + if (auto* csize = memCopy->size->dynCast()) { + auto bytes = csize->value.geti32(); + Builder builder(*getModule()); + + switch (bytes) { + case 0: { + if (options.ignoreImplicitTraps) { + // memory.copy(dst, src, 0) ==> {drop(dst), drop(src)} + return builder.makeBlock({builder.makeDrop(memCopy->dest), + builder.makeDrop(memCopy->source)}); + } + break; + } + case 1: + case 2: + case 4: { + return builder.makeStore( + bytes, // bytes + 0, // offset + 1, // align + memCopy->dest, + builder.makeLoad(bytes, false, 0, 1, memCopy->source, Type::i32), + Type::i32); + } + case 8: { + return builder.makeStore( + bytes, // bytes + 0, // offset + 1, // align + memCopy->dest, + builder.makeLoad(bytes, false, 0, 1, memCopy->source, Type::i64), + Type::i64); + } + case 16: { + if (options.shrinkLevel == 0) { + // This adds an extra 2 bytes so apply it only for + // minimal shrink level + if (getModule()->features.hasSIMD()) { + return builder.makeStore( + bytes, // bytes + 0, // offset + 1, // align + memCopy->dest, + builder.makeLoad( + bytes, false, 0, 1, memCopy->source, Type::v128), + Type::v128); + } + } + } + default: { + } + } + } + return nullptr; + } + + // given a binary expression with equal children and no side effects in + // either, we can fold various things + Expression* optimizeBinaryWithEqualEffectlessChildren(Binary* binary) { + // TODO add: perhaps worth doing 2*x if x is quite large? + switch (binary->op) { + case SubInt32: + case XorInt32: + case SubInt64: + case XorInt64: + return LiteralUtils::makeZero(binary->left->type, *getModule()); + case NeInt32: + case LtSInt32: + case LtUInt32: + case GtSInt32: + case GtUInt32: + case NeInt64: + case LtSInt64: + case LtUInt64: + case GtSInt64: + case GtUInt64: + return LiteralUtils::makeZero(Type::i32, *getModule()); + case AndInt32: + case OrInt32: + case AndInt64: + case OrInt64: + return binary->left; + case EqInt32: + case LeSInt32: + case LeUInt32: + case GeSInt32: + case GeUInt32: + case EqInt64: + case LeSInt64: + case LeUInt64: + case GeSInt64: + case GeUInt64: + return LiteralUtils::makeFromInt32(1, Type::i32, *getModule()); + default: + return nullptr; + } + } + + BinaryOp invertBinaryOp(BinaryOp op) { + // use de-morgan's laws + switch (op) { + case EqInt32: + return NeInt32; + case NeInt32: + return EqInt32; + case LtSInt32: + return GeSInt32; + case LtUInt32: + return GeUInt32; + case LeSInt32: + return GtSInt32; + case LeUInt32: + return GtUInt32; + case GtSInt32: + return LeSInt32; + case GtUInt32: + return LeUInt32; + case GeSInt32: + return LtSInt32; + case GeUInt32: + return LtUInt32; + + case EqInt64: + return NeInt64; + case NeInt64: + return EqInt64; + case LtSInt64: + return GeSInt64; + case LtUInt64: + return GeUInt64; + case LeSInt64: + return GtSInt64; + case LeUInt64: + return GtUInt64; + case GtSInt64: + return LeSInt64; + case GtUInt64: + return LeUInt64; + case GeSInt64: + return LtSInt64; + case GeUInt64: + return LtUInt64; + + case EqFloat32: + return NeFloat32; + case NeFloat32: + return EqFloat32; + + case EqFloat64: + return NeFloat64; + case NeFloat64: + return EqFloat64; + + default: + return InvalidBinary; + } + } + + BinaryOp makeUnsignedBinaryOp(BinaryOp op) { + switch (op) { + case DivSInt32: + return DivUInt32; + case RemSInt32: + return RemUInt32; + case ShrSInt32: + return ShrUInt32; + case LtSInt32: + return LtUInt32; + case LeSInt32: + return LeUInt32; + case GtSInt32: + return GtUInt32; + case GeSInt32: + return GeUInt32; + + case DivSInt64: + return DivUInt64; + case RemSInt64: + return RemUInt64; + case ShrSInt64: + return ShrUInt64; + case LtSInt64: + return LtUInt64; + case LeSInt64: + return LeUInt64; + case GtSInt64: + return GtUInt64; + case GeSInt64: + return GeUInt64; + + default: + return InvalidBinary; + } + } + + bool isSymmetric(Binary* binary) { + if (Properties::isSymmetric(binary)) { + return true; + } + switch (binary->op) { + case AddFloat32: + case MulFloat32: + case AddFloat64: + case MulFloat64: { + // If the LHS is known to be non-NaN, the operands can commute. + // We don't care about the RHS because right now we only know if + // an expression is non-NaN if it is constant, but if the RHS is + // constant, then this expression is already canonicalized. + if (auto* c = binary->left->dynCast()) { + return !c->value.isNaN(); + } + return false; + } + default: + return false; + } + } +}; + +Pass* createOptimizeInstructionsPass() { return new OptimizeInstructions(); } + +} // namespace wasm diff --git a/binaryen/src/passes/PickLoadSigns.cpp b/binaryen/src/passes/PickLoadSigns.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/passes/PickLoadSigns.cpp @@ -0,0 +1,121 @@ +/* + * Copyright 2017 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include + +namespace wasm { + +// Adjust load signedness based on usage. If a load only has uses that sign or +// unsign it anyhow, then it could be either, and picking the popular one can +// help remove the most sign/unsign operations +// unsigned, then it could be either + +struct PickLoadSigns : public WalkerPass> { + bool isFunctionParallel() override { return true; } + + Pass* create() override { return new PickLoadSigns; } + + struct Usage { + Index signedUsages = 0; + Index signedBits; + Index unsignedUsages = 0; + Index unsignedBits; + Index totalUsages = 0; + }; + std::vector usages; // local index => usage + + // loads that write to a local => the local + std::unordered_map loads; + + void doWalkFunction(Function* func) { + // prepare + usages.resize(func->getNumLocals()); + // walk + ExpressionStackWalker::doWalkFunction(func); + // optimize + optimize(); + } + + void visitLocalGet(LocalGet* curr) { + // this is a use. check from the context what it is, signed or unsigned, + // etc. + auto& usage = usages[curr->index]; + usage.totalUsages++; + if (expressionStack.size() >= 2) { + auto* parent = expressionStack[expressionStack.size() - 2]; + if (Properties::getZeroExtValue(parent)) { + auto bits = Properties::getZeroExtBits(parent); + if (usage.unsignedUsages == 0) { + usage.unsignedBits = bits; + } else if (usage.unsignedBits != bits) { + usage.unsignedBits = 0; + } + usage.unsignedUsages++; + } else if (expressionStack.size() >= 3) { + auto* grandparent = expressionStack[expressionStack.size() - 3]; + if (Properties::getSignExtValue(grandparent)) { + auto bits = Properties::getSignExtBits(grandparent); + if (usage.signedUsages == 0) { + usage.signedBits = bits; + } else if (usage.signedBits != bits) { + usage.signedBits = 0; + } + usage.signedUsages++; + } + } + } + } + + void visitLocalSet(LocalSet* curr) { + if (curr->isTee()) { + // we can't modify a tee, the value is used elsewhere + return; + } + if (auto* load = curr->value->dynCast()) { + loads[load] = curr->index; + } + } + + void optimize() { + // optimize based on the info we saw + for (auto& pair : loads) { + auto* load = pair.first; + auto index = pair.second; + auto& usage = usages[index]; + // if we can't optimize, give up + if (usage.totalUsages == 0 || // no usages, so no idea + usage.signedUsages + usage.unsignedUsages != + usage.totalUsages || // non-sign/unsigned usages, so cannot change + (usage.signedUsages != 0 && + usage.signedBits != + load->bytes * 8) || // sign usages exist but the wrong size + (usage.unsignedUsages != 0 && + usage.unsignedBits != + load->bytes * 8)) { // unsigned usages exist but the wrong size + continue; + } + // we can pick the optimal one. our hope is to remove 2 items per + // signed use (two shifts), so we factor that in + load->signed_ = usage.signedUsages * 2 >= usage.unsignedUsages; + } + } +}; + +Pass* createPickLoadSignsPass() { return new PickLoadSigns(); } + +} // namespace wasm diff --git a/binaryen/src/passes/PostAssemblyScript.cpp b/binaryen/src/passes/PostAssemblyScript.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/passes/PostAssemblyScript.cpp @@ -0,0 +1,641 @@ +/* + * Copyright 2019 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// Misc optimizations that are useful for and/or are only valid for +// AssemblyScript output. +// + +#include "ir/flat.h" +#include "ir/local-graph.h" +#include "pass.h" +#include "wasm-builder.h" +#include "wasm-traversal.h" +#include "wasm.h" +#include +#include +#ifdef POST_ASSEMBLYSCRIPT_DEBUG +#include "wasm-printing.h" +#include +#endif + +namespace wasm { + +namespace PostAssemblyScript { + +static Name RETAIN = Name("~lib/rt/pure/__retain"); +static Name RELEASE = Name("~lib/rt/pure/__release"); +static Name ALLOC = Name("~lib/rt/tlsf/__alloc"); +static Name ALLOCARRAY = Name("~lib/rt/__allocArray"); + +template using Map = std::unordered_map; +template using Set = std::unordered_set; + +// A variant of LocalGraph that considers only assignments when computing +// influences. +// +// This allows us to find locals aliasing a retain, while ignoring other +// influences. +// +// For example, we are interested in +// +// var a = __retain(X) +// var b = a; +// __release(b); // releases X +// +// but not in +// +// var a = __retain(X); +// var b = someFunction(a); +// __release(b); +// return a; +// +// since the latter releases not 'X' but the reference returned by the call, +// which is usually something else. +struct AliasGraph : LocalGraph { + AliasGraph(Function* func) : LocalGraph(func) {} + void computeInfluences() { + for (auto& pair : locations) { + auto* curr = pair.first; + if (auto* set = curr->dynCast()) { + if (auto* get = set->value->dynCast()) { + getInfluences[get].insert(set); + } + } else { + auto* get = curr->cast(); + for (auto* set : getSetses[get]) { + setInfluences[set].insert(get); + } + } + } + } +}; + +// Tests if the given call calls retain. Note that this differs from what we +// consider a full retain pattern, which must also set a local. +static bool isRetainCall(Call* expr) { + // __retain(...) + return expr->target == RETAIN && expr->type == Type::i32 && + expr->operands.size() == 1 && expr->operands[0]->type == Type::i32; +} + +// Tests if a local.set is considered to be a full retain pattern. +static bool isRetain(LocalSet* expr) { + // local.set(X, __retain(...)) + if (auto* call = expr->value->dynCast()) { + return isRetainCall(call); + } + return false; +} + +#ifndef NDEBUG +// Tests if the given location is that of a full retain pattern. +static bool isRetainLocation(Expression** expr) { + if (expr != nullptr) { + if (auto localSet = (*expr)->dynCast()) { + return isRetain(localSet); + } + } + return false; +} +#endif + +// Tests if the given call calls release. Note that this differs from what we +// consider a full release pattern, which must also get a local. +static bool isReleaseCall(Call* expr) { + // __release(...) + return expr->target == RELEASE && expr->type == Type::none && + expr->operands.size() == 1 && expr->operands[0]->type == Type::i32; +} + +// Tests if the given location is that of a full release pattern. Note that +// the local.get is our key when checking for releases to align with +// AliasGraph, and not the outer call, which is also the reason why there is +// no `isRelease` as we can't tell from the local.get alone. +static bool isReleaseLocation(Expression** expr) { + // __release(local.get(X, ...)) + if (expr != nullptr) { + if (auto* call = (*expr)->dynCast()) { + return isReleaseCall(call) && call->operands[0]->is(); + } + } + return false; +} + +// Tests if the given call calls any allocation function. +static bool isAllocCall(Call* expr) { + return (expr->target == ALLOC || expr->target == ALLOCARRAY) && + expr->type == Type::i32; +} + +// A pass that eliminates redundant retain and release calls. +// +// Does a cheap traversal first, remembering ARC-style patterns, and goes all-in +// only if it finds any. +// +// This is based on the assumption that the compiler is not allowed to emit +// unbalanced retains or releases, except if +// +// * a value is returned or otherwise escapes in one branch or +// * a branch is being internally unified by the compiler +// +// which we detect below. In turn, we do not have to deal with control +// structures but can instead look for escapes reached (by any alias) using +// AliasGraph. +// +// For example, in code like +// +// var a = __retain(X); +// if (cond) { +// return a; +// } +// __release(a); +// return null; +// +// we cannot eliminate the retain/release pair because the implementation +// dictates that returned references must remain retained for the caller since +// dropping to RC=0 on the boundary would prematurely free the object. +// +// Typical patterns this recognizes are simple pairs of the form +// +// var a = __retain(X); +// __release(a); +// +// retains with balanced releases of the form +// +// var a = __retain(X); +// if (cond) { +// __release(a); +// } else { +// __release(a); +// } +// +// releases with balanced retains of the form +// +// var a; +// if (cond) { +// a = __retain(X); +// } else { +// a = __retain(Y); +// } +// __release(a); +// +// including technically invalid patterns assumed to be not present in compiler +// output, like: +// +// var b = __retain(a); +// if (cond) { +// __release(b); // unbalanced release +// } +// +// To detect the latter, we'd have to follow control structures around, which +// we don't do since it isn't neccessary / to keep the amount of work minimal. +struct OptimizeARC : public WalkerPass> { + + bool isFunctionParallel() override { return true; } + + Pass* create() override { return new OptimizeARC; } + + // Sets that are retains, to location + Map retains; + + // Gets that are releases, to location + Map releases; + + // Gets that are escapes, i.e. being returned or thrown + Set escapes; + + void visitLocalSet(LocalSet* curr) { + if (isRetain(curr)) { + retains[curr] = getCurrentPointer(); + } + } + + void visitCall(Call* curr) { + auto** currp = getCurrentPointer(); + if (isReleaseLocation(currp)) { + releases[curr->operands[0]->cast()] = currp; + } + } + + void visitReturn(Return* curr) { + // return(local.get(X, ...)) ? + // indicates that an object is returned from one function and given to + // another, so releasing it would be invalid. + auto* value = curr->value; + if (value) { + if (auto* localGet = value->dynCast()) { + escapes.insert(localGet); + } + } + } + + void visitThrow(Throw* curr) { + // throw(..., local.get(X, ...), ...) ? + // indicates that an object is thrown in one function and can be caught + // anywhere, like in another function, so releasing it would be invalid. + for (auto* operand : curr->operands) { + if (auto* localGet = operand->dynCast()) { + escapes.insert(localGet); + break; + } + } + } + + void eliminateRetain(Expression** location) { + assert(isRetainLocation(location)); + auto* localSet = (*location)->cast(); + localSet->value = localSet->value->cast()->operands[0]; + } + + void eliminateRelease(Expression** location) { + assert(isReleaseLocation(location)); + Builder builder(*getModule()); + *location = builder.makeNop(); + } + + // Tests if a retain reaches an escape and thus is considered necessary. + bool + testReachesEscape(LocalSet* retain, AliasGraph& graph, Set& seen) { + for (auto* localGet : graph.setInfluences[retain]) { + if (releases.find(localGet) != releases.end()) { + continue; + } + if (escapes.find(localGet) != escapes.end()) { + return true; + } + for (auto* localSet : graph.getInfluences[localGet]) { + if (seen.find(localSet) == seen.end()) { + seen.insert(localSet); + if (testReachesEscape(localSet, graph, seen)) { + return true; + } + } + } + } + return false; + } + + bool testReachesEscape(LocalSet* retain, AliasGraph& graph) { + Set seen; + return testReachesEscape(retain, graph, seen); + } + + // Collects all reachable releases of a retain. + void collectReleases(LocalSet* retain, + AliasGraph& graph, + Set& found, + Set& seen) { + for (auto* localGet : graph.setInfluences[retain]) { + auto foundRelease = releases.find(localGet); + if (foundRelease != releases.end()) { + found.insert(foundRelease->second); + } else { + for (auto* localSet : graph.getInfluences[localGet]) { + if (seen.find(localSet) == seen.end()) { + seen.insert(localSet); + collectReleases(localSet, graph, found, seen); + } + } + } + } + } + + void collectReleases(LocalSet* retain, + AliasGraph& graph, + Set& found) { + Set seen; + collectReleases(retain, graph, found, seen); + } + + // Given a retain, gets the retained expression + static Expression* getRetainedExpression(LocalSet* retain) { + assert(isRetain(retain)); + return retain->value->cast()->operands[0]; + } + + // Tests if a retained value originates at an allocation and thus is + // considered necessary. + bool testRetainsAllocation(Expression* retained, + AliasGraph& graph, + Set& seen) { + if (auto* call = retained->dynCast()) { + if (call->target == ALLOC || call->target == ALLOCARRAY) { + return true; + } + } else { + if (auto* localGet = retained->dynCast()) { + for (auto* localSet : graph.getSetses[localGet]) { + if (localSet != nullptr) { + if (seen.find(localSet) == seen.end()) { + seen.insert(localSet); + if (testRetainsAllocation(localSet->value, graph, seen)) { + return true; + } + } + } + } + } + } + return false; + } + + bool testRetainsAllocation(Expression* retained, AliasGraph& graph) { + Set seen; + return testRetainsAllocation(retained, graph, seen); + } + + // Given a release location, gets the local.get that is our release indicator + static LocalGet* getReleaseByLocation(Expression** releaseLocation) { + assert(isReleaseLocation(releaseLocation)); + return (*releaseLocation)->cast()->operands[0]->cast(); + } + + // Tests if a release has balanced retains, that is it is being retained in + // any path leading to the release. For example + // + // var c = somethingElse() || a; + // ... + // + // which compiles to + // + // if (!(b = somethingElse())) { + // b = __retain(a); + // } + // var c = b; + // ... + // __release(c); + // + // is unbalanced since it reaches a retain and something else. Here, the + // compiler inserts the retain call because it must unify the two branches + // since the result of `somethingElse()` is known to be retained for the + // caller and the other branch must yield a retained value as well. + bool testBalancedRetains(LocalGet* release, + AliasGraph& graph, + Map& cache, + Set& seen) { + auto cached = cache.find(release); + if (cached != cache.end()) { + return cached->second; + } + for (auto* localSet : graph.getSetses[release]) { + if (localSet == nullptr) { + return cache[release] = false; + } + if (retains.find(localSet) == retains.end()) { + if (auto* localGet = localSet->value->dynCast()) { + if (seen.find(localGet) == seen.end()) { + seen.insert(localGet); + if (!testBalancedRetains(localGet, graph, cache, seen)) { + return cache[release] = false; + } + } else { + return cache[release] = false; + } + } else { + return cache[release] = false; + } + } + } + return cache[release] = true; + } + + bool testBalancedRetains(LocalGet* release, + AliasGraph& graph, + Map& cache) { + Set seen; + return testBalancedRetains(release, graph, cache, seen); + } + + void doWalkFunction(Function* func) { + Flat::verifyFlatness(func); +#ifdef POST_ASSEMBLYSCRIPT_DEBUG + std::cerr << "[PostAssemblyScript::OptimizeARC] walking " << func->name + << "\n"; +#endif + super::doWalkFunction(func); + if (retains.empty()) { +#ifdef POST_ASSEMBLYSCRIPT_DEBUG + std::cerr << " no ARC code\n"; +#endif + return; + } + + AliasGraph graph(func); + graph.computeInfluences(); + + Set redundantRetains; + Set redundantReleases; + Map balancedRetainsCache; + + // For each retain, check that it + // + // * doesn't reach an escape + // * doesn't retain an allocation + // * reaches at least one release + // * reaches only releases with balanced retains + // + for (auto& pair : retains) { + auto* retain = pair.first; + auto** retainLocation = pair.second; + if (!testReachesEscape(retain, graph)) { + if (!testRetainsAllocation(getRetainedExpression(retain), graph)) { + Set releaseLocations; + collectReleases(retain, graph, releaseLocations); + if (!releaseLocations.empty()) { + bool allBalanced = true; + for (auto** releaseLocation : releaseLocations) { + if (!testBalancedRetains(getReleaseByLocation(releaseLocation), + graph, + balancedRetainsCache)) { + allBalanced = false; + break; + } + } + if (allBalanced) { +#ifdef POST_ASSEMBLYSCRIPT_DEBUG + std::cerr << " eliminating "; + WasmPrinter::printExpression(retain, std::cerr, true); + std::cerr << " reaching\n"; +#endif + redundantRetains.insert(retainLocation); + for (auto** getLocation : releaseLocations) { +#ifdef POST_ASSEMBLYSCRIPT_DEBUG + std::cerr << " "; + WasmPrinter::printExpression(*getLocation, std::cerr, true); + std::cerr << "\n"; +#endif + redundantReleases.insert(getLocation); + } +#ifdef POST_ASSEMBLYSCRIPT_DEBUG + } else { + std::cerr << " cannot eliminate "; + WasmPrinter::printExpression(retain, std::cerr, true); + std::cerr << " - unbalanced\n"; +#endif + } +#ifdef POST_ASSEMBLYSCRIPT_DEBUG + } else { + std::cerr << " cannot eliminate "; + WasmPrinter::printExpression(retain, std::cerr, true); + std::cerr << " - zero releases\n"; +#endif + } +#ifdef POST_ASSEMBLYSCRIPT_DEBUG + } else { + std::cerr << " cannot eliminate "; + WasmPrinter::printExpression(retain, std::cerr, true); + std::cerr << " - retains allocation\n"; +#endif + } +#ifdef POST_ASSEMBLYSCRIPT_DEBUG + } else { + std::cerr << " cannot eliminate "; + WasmPrinter::printExpression(retain, std::cerr, true); + std::cerr << " - reaches return\n"; +#endif + } + } + for (auto** location : redundantRetains) { + eliminateRetain(location); + } + for (auto** location : redundantReleases) { + eliminateRelease(location); + } +#ifdef POST_ASSEMBLYSCRIPT_DEBUG + std::cerr << " eliminated " << redundantRetains.size() << "/" + << retains.size() << " retains and " << redundantReleases.size() + << "/" << releases.size() << " releases\n"; +#endif + } +}; + +// Eliminating retains and releases makes it more likely that other passes lead +// to collapsed release/retain pairs that are not full retain or release +// patterns, and this pass finalizes such pairs. Typical patterns are entire +// unnecessary allocations of the form +// +// __release(__retain(__alloc(...)); +// +// otherwise unnecessary pairs of the form +// +// __release(__retain(...)); +// +// or retains/releases of constants which indicate data in static memory which +// are unnecessary to refcount: +// +// __retain("staticString"); +// +// __release("staticString"); +// +struct FinalizeARC : public WalkerPass> { + + bool isFunctionParallel() override { return true; } + + Pass* create() override { return new FinalizeARC; } + + uint32_t eliminatedAllocations = 0; + uint32_t eliminatedRetains = 0; + uint32_t eliminatedReleases = 0; + + void visitCall(Call* curr) { + if (isReleaseCall(curr)) { + if (auto* releasedCall = curr->operands[0]->dynCast()) { + if (isRetainCall(releasedCall)) { + if (auto* retainedCall = releasedCall->operands[0]->dynCast()) { + if (isAllocCall(retainedCall)) { + // __release(__retain(__alloc(...))) - unnecessary allocation +#ifdef POST_ASSEMBLYSCRIPT_DEBUG + std::cerr << " finalizing "; + WasmPrinter::printExpression(curr, std::cerr, true); + std::cerr << " - unnecessary allocation\n"; +#endif + Builder builder(*getModule()); + replaceCurrent(builder.makeNop()); + ++eliminatedAllocations; + ++eliminatedRetains; + ++eliminatedReleases; + return; + } + } + // __release(__retain(...)) - unnecessary pair +#ifdef POST_ASSEMBLYSCRIPT_DEBUG + std::cerr << " finalizing "; + WasmPrinter::printExpression(curr, std::cerr, true); + std::cerr << " - unnecessary pair\n"; +#endif + Builder builder(*getModule()); + replaceCurrent(builder.makeDrop(releasedCall->operands[0])); + ++eliminatedRetains; + ++eliminatedReleases; + } + } else if (curr->operands[0]->is()) { + // __release(42) - unnecessary static release +#ifdef POST_ASSEMBLYSCRIPT_DEBUG + std::cerr << " finalizing "; + WasmPrinter::printExpression(curr, std::cerr, true); + std::cerr << " - static release\n"; +#endif + Builder builder(*getModule()); + replaceCurrent(builder.makeNop()); + ++eliminatedReleases; + } + } else if (isRetainCall(curr)) { + if (auto* retainedConst = curr->operands[0]->dynCast()) { + // __retain(42) - unnecessary static retain +#ifdef POST_ASSEMBLYSCRIPT_DEBUG + std::cerr << " finalizing "; + WasmPrinter::printExpression(curr, std::cerr, true); + std::cerr << " - static retain\n"; +#endif + replaceCurrent(retainedConst); + ++eliminatedRetains; + } + } + } + + void doWalkFunction(Function* func) { +#ifdef POST_ASSEMBLYSCRIPT_DEBUG + std::cerr << "[PostAssemblyScript::FinalizeARC] walking " << func->name + << "\n"; +#endif + super::doWalkFunction(func); +#ifdef POST_ASSEMBLYSCRIPT_DEBUG + if (eliminatedAllocations > 0 || eliminatedRetains > 0 || + eliminatedReleases > 0) { + std::cerr << " finalized " << eliminatedAllocations << " allocations, " + << eliminatedRetains << " retains and" << eliminatedReleases + << " releases\n"; + } else { + std::cerr << " nothing to do\n"; + } +#endif + } +}; + +} // namespace PostAssemblyScript + +// declare passes + +Pass* createPostAssemblyScriptPass() { + return new PostAssemblyScript::OptimizeARC(); +} + +Pass* createPostAssemblyScriptFinalizePass() { + return new PostAssemblyScript::FinalizeARC(); +} + +} // namespace wasm diff --git a/binaryen/src/passes/PostEmscripten.cpp b/binaryen/src/passes/PostEmscripten.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/passes/PostEmscripten.cpp @@ -0,0 +1,170 @@ +/* + * Copyright 2015 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// Misc optimizations that are useful for and/or are only valid for +// emscripten output. +// + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define DEBUG_TYPE "post-emscripten" + +namespace wasm { + +namespace { + +static bool isInvoke(Function* F) { + return F->imported() && F->module == ENV && F->base.startsWith("invoke_"); +} + +struct OptimizeCalls : public WalkerPass> { + bool isFunctionParallel() override { return true; } + + Pass* create() override { return new OptimizeCalls; } + + void visitCall(Call* curr) { + // special asm.js imports can be optimized + auto* func = getModule()->getFunction(curr->target); + if (!func->imported()) { + return; + } + if (func->module == GLOBAL_MATH) { + if (func->base == POW) { + if (auto* exponent = curr->operands[1]->dynCast()) { + if (exponent->value == Literal(double(2.0))) { + // This is just a square operation, do a multiply + Localizer localizer(curr->operands[0], getFunction(), getModule()); + Builder builder(*getModule()); + replaceCurrent(builder.makeBinary( + MulFloat64, + localizer.expr, + builder.makeLocalGet(localizer.index, localizer.expr->type))); + } else if (exponent->value == Literal(double(0.5))) { + // This is just a square root operation + replaceCurrent( + Builder(*getModule()).makeUnary(SqrtFloat64, curr->operands[0])); + } + } + } + } + } +}; + +} // namespace + +struct PostEmscripten : public Pass { + void run(PassRunner* runner, Module* module) override { + // Optimize calls + OptimizeCalls().run(runner, module); + + // Optimize exceptions + optimizeExceptions(runner, module); + } + + // Optimize exceptions (and setjmp) by removing unnecessary invoke* calls. + // An invoke is a call to JS with a function pointer; JS does a try-catch + // and calls the pointer, catching and reporting any error. If we know no + // exception will be thrown, we can simply skip the invoke. + void optimizeExceptions(PassRunner* runner, Module* module) { + // First, check if this code even uses invokes. + bool hasInvokes = false; + for (auto& imp : module->functions) { + if (isInvoke(imp.get())) { + hasInvokes = true; + } + } + if (!hasInvokes) { + return; + } + // Next, see if the Table is flat, which we need in order to see where + // invokes go statically. (In dynamic linking, the table is not flat, + // and we can't do this.) + TableUtils::FlatTable flatTable(module->table); + if (!flatTable.valid) { + return; + } + // This code has exceptions. Find functions that definitely cannot throw, + // and remove invokes to them. + struct Info + : public ModuleUtils::CallGraphPropertyAnalysis::FunctionInfo { + bool canThrow = false; + }; + ModuleUtils::CallGraphPropertyAnalysis analyzer( + *module, [&](Function* func, Info& info) { + if (func->imported()) { + // Assume any import can throw. We may want to reduce this to just + // longjmp/cxa_throw/etc. + info.canThrow = true; + } + }); + + // Assume an indirect call might throw. + analyzer.propagateBack( + [](const Info& info) { return info.canThrow; }, + [](const Info& info) { return true; }, + [](Info& info, Function* reason) { info.canThrow = true; }, + analyzer.IndirectCallsHaveProperty); + + // Apply the information. + struct OptimizeInvokes : public WalkerPass> { + bool isFunctionParallel() override { return true; } + + Pass* create() override { return new OptimizeInvokes(map, flatTable); } + + std::map& map; + TableUtils::FlatTable& flatTable; + + OptimizeInvokes(std::map& map, + TableUtils::FlatTable& flatTable) + : map(map), flatTable(flatTable) {} + + void visitCall(Call* curr) { + auto* target = getModule()->getFunction(curr->target); + if (isInvoke(target)) { + // The first operand is the function pointer index, which must be + // constant if we are to optimize it statically. + if (auto* index = curr->operands[0]->dynCast()) { + auto actualTarget = flatTable.names.at(index->value.geti32()); + if (!map[getModule()->getFunction(actualTarget)].canThrow) { + // This invoke cannot throw! Make it a direct call. + curr->target = actualTarget; + for (Index i = 0; i < curr->operands.size() - 1; i++) { + curr->operands[i] = curr->operands[i + 1]; + } + curr->operands.resize(curr->operands.size() - 1); + } + } + } + } + }; + OptimizeInvokes(analyzer.map, flatTable).run(runner, module); + } +}; + +Pass* createPostEmscriptenPass() { return new PostEmscripten(); } + +} // namespace wasm diff --git a/binaryen/src/passes/Precompute.cpp b/binaryen/src/passes/Precompute.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/passes/Precompute.cpp @@ -0,0 +1,347 @@ +/* + * Copyright 2016 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// Computes code at compile time where possible, replacing it with the +// computed constant. +// +// The "propagate" variant of this pass also propagates constants across +// sets and gets, which implements a standard constant propagation. +// +// Possible nondeterminism: WebAssembly NaN signs are nondeterministic, +// and this pass may optimize e.g. a float 0 / 0 into +nan while a VM may +// emit -nan, which can be a noticeable difference if the bits are +// looked at. +// + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace wasm { + +typedef std::unordered_map GetValues; + +// Precomputes an expression. Errors if we hit anything that can't be +// precomputed. Inherits most of its functionality from +// ConstantExpressionRunner, which it shares with the C-API, but adds handling +// of GetValues computed during the precompute pass. +class PrecomputingExpressionRunner + : public ConstantExpressionRunner { + + // Concrete values of gets computed during the pass, which the runner does not + // know about since it only records values of sets it visits. + GetValues& getValues; + + // Limit evaluation depth for 2 reasons: first, it is highly unlikely + // that we can do anything useful to precompute a hugely nested expression + // (we should succed at smaller parts of it first). Second, a low limit is + // helpful to avoid platform differences in native stack sizes. + static const Index MAX_DEPTH = 50; + + // Limit loop iterations since loops might be infinite. Since we are going to + // replace the expression and must preserve side effects, we limit this to the + // very first iteration because a side effect would be necessary to achieve + // more than one iteration before becoming concrete. + static const Index MAX_LOOP_ITERATIONS = 1; + +public: + PrecomputingExpressionRunner(Module* module, + GetValues& getValues, + bool replaceExpression) + : ConstantExpressionRunner( + module, + replaceExpression ? FlagValues::PRESERVE_SIDEEFFECTS + : FlagValues::DEFAULT, + MAX_DEPTH, + MAX_LOOP_ITERATIONS), + getValues(getValues) {} + + Flow visitLocalGet(LocalGet* curr) { + auto iter = getValues.find(curr); + if (iter != getValues.end()) { + auto values = iter->second; + if (values.isConcrete()) { + return Flow(values); + } + } + return ConstantExpressionRunner< + PrecomputingExpressionRunner>::visitLocalGet(curr); + } +}; + +struct Precompute + : public WalkerPass< + PostWalker>> { + bool isFunctionParallel() override { return true; } + + Pass* create() override { return new Precompute(propagate); } + + bool propagate = false; + + Precompute(bool propagate) : propagate(propagate) {} + + GetValues getValues; + + bool worked; + + void doWalkFunction(Function* func) { + // if propagating, we may need multiple rounds: each propagation can + // lead to the main walk removing code, which might open up more + // propagation opportunities + do { + getValues.clear(); + // with extra effort, we can utilize the get-set graph to precompute + // things that use locals that are known to be constant. otherwise, + // we just look at what is immediately before us + if (propagate) { + optimizeLocals(func); + } + // do the main walk over everything + worked = false; + super::doWalkFunction(func); + } while (propagate && worked); + } + + template void reuseConstantNode(T* curr, Flow flow) { + if (flow.values.isConcrete()) { + // reuse a const / ref.null / ref.func node if there is one + if (curr->value && flow.values.size() == 1) { + Literal singleValue = flow.getSingleValue(); + if (singleValue.type.isNumber()) { + if (auto* c = curr->value->template dynCast()) { + c->value = singleValue; + c->finalize(); + curr->finalize(); + return; + } + } else if (singleValue.isNull()) { + if (auto* n = curr->value->template dynCast()) { + n->finalize(singleValue.type); + curr->finalize(); + return; + } + } else if (singleValue.type == Type::funcref) { + if (auto* r = curr->value->template dynCast()) { + r->func = singleValue.getFunc(); + r->finalize(); + curr->finalize(); + return; + } + } + } + curr->value = flow.getConstExpression(*getModule()); + } else { + curr->value = nullptr; + } + curr->finalize(); + } + + void visitExpression(Expression* curr) { + // TODO: if local.get, only replace with a constant if we don't care about + // size...? + if (Properties::isConstantExpression(curr) || curr->is()) { + return; + } + // Until engines implement v128.const and we have SIMD-aware optimizations + // that can break large v128.const instructions into smaller consts and + // splats, do not try to precompute v128 expressions. + if (curr->type.isVector()) { + return; + } + // try to evaluate this into a const + Flow flow = precomputeExpression(curr); + if (flow.getType().hasVector()) { + return; + } + if (flow.breaking()) { + if (flow.breakTo == NONCONSTANT_FLOW) { + return; + } + if (flow.breakTo == RETURN_FLOW) { + // this expression causes a return. if it's already a return, reuse the + // node + if (auto* ret = curr->dynCast()) { + reuseConstantNode(ret, flow); + } else { + Builder builder(*getModule()); + replaceCurrent(builder.makeReturn( + flow.values.isConcrete() ? flow.getConstExpression(*getModule()) + : nullptr)); + } + return; + } + // this expression causes a break, emit it directly. if it's already a br, + // reuse the node. + if (auto* br = curr->dynCast()) { + br->name = flow.breakTo; + br->condition = nullptr; + reuseConstantNode(br, flow); + } else { + Builder builder(*getModule()); + replaceCurrent(builder.makeBreak( + flow.breakTo, + flow.values.isConcrete() ? flow.getConstExpression(*getModule()) + : nullptr)); + } + return; + } + // this was precomputed + if (flow.values.isConcrete()) { + replaceCurrent(flow.getConstExpression(*getModule())); + worked = true; + } else { + ExpressionManipulator::nop(curr); + } + } + + void visitFunction(Function* curr) { + // removing breaks can alter types + ReFinalize().walkFunctionInModule(curr, getModule()); + } + +private: + // Precompute an expression, returning a flow, which may be a constant + // (that we can replace the expression with if replaceExpression is set). + Flow precomputeExpression(Expression* curr, bool replaceExpression = true) { + try { + return PrecomputingExpressionRunner( + getModule(), getValues, replaceExpression) + .visit(curr); + } catch (PrecomputingExpressionRunner::NonconstantException&) { + return Flow(NONCONSTANT_FLOW); + } + } + + // Precomputes the value of an expression, as opposed to the expression + // itself. This differs from precomputeExpression in that we care about + // the value the expression will have, which we cannot necessary replace + // the expression with. For example, + // (local.tee (i32.const 1)) + // will have value 1 which we can optimize here, but in precomputeExpression + // we could not do anything. + Literals precomputeValue(Expression* curr) { + // Note that we set replaceExpression to false, as we just care about + // the value here. + Flow flow = precomputeExpression(curr, false /* replaceExpression */); + if (flow.breaking()) { + return {}; + } + return flow.values; + } + + // Propagates values around. Returns whether we propagated. + void optimizeLocals(Function* func) { + // using the graph of get-set interactions, do a constant-propagation type + // operation: note which sets are assigned locals, then see if that lets us + // compute other sets as locals (since some of the gets they read may be + // constant). + // compute all dependencies + LocalGraph localGraph(func); + localGraph.computeInfluences(); + localGraph.computeSSAIndexes(); + // prepare the work list. we add things here that might change to a constant + // initially, that means everything + std::unordered_set work; + for (auto& pair : localGraph.locations) { + auto* curr = pair.first; + work.insert(curr); + } + // the constant value, or none if not a constant + std::unordered_map setValues; + // propagate constant values + while (!work.empty()) { + auto iter = work.begin(); + auto* curr = *iter; + work.erase(iter); + // see if this set or get is actually a constant value, and if so, + // mark it as such and add everything it influences to the work list, + // as they may be constant too. + if (auto* set = curr->dynCast()) { + if (setValues[set].isConcrete()) { + continue; // already known constant + } + auto values = setValues[set] = + precomputeValue(Properties::getFallthrough( + set->value, getPassOptions(), getModule()->features)); + if (values.isConcrete()) { + for (auto* get : localGraph.setInfluences[set]) { + work.insert(get); + } + } + } else { + auto* get = curr->cast(); + if (getValues[get].size() >= 1) { + continue; // already known constant + } + // for this get to have constant value, all sets must agree + Literals values; + bool first = true; + for (auto* set : localGraph.getSetses[get]) { + Literals curr; + if (set == nullptr) { + if (getFunction()->isVar(get->index)) { + curr = + Literal::makeZeros(getFunction()->getLocalType(get->index)); + } else { + // it's a param, so it's hopeless + values = {}; + break; + } + } else { + curr = setValues[set]; + } + if (curr.isNone()) { + // not a constant, give up + values = {}; + break; + } + // we found a concrete value. compare with the current one + if (first) { + values = curr; // this is the first + first = false; + } else { + if (values != curr) { + // not the same, give up + values = {}; + break; + } + } + } + // we may have found a value + if (values.isConcrete()) { + // we did! + getValues[get] = values; + for (auto* set : localGraph.getInfluences[get]) { + work.insert(set); + } + } + } + } + } +}; + +Pass* createPrecomputePass() { return new Precompute(false); } + +Pass* createPrecomputePropagatePass() { return new Precompute(true); } + +} // namespace wasm diff --git a/binaryen/src/passes/Print.cpp b/binaryen/src/passes/Print.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/passes/Print.cpp @@ -0,0 +1,2808 @@ +/* + * Copyright 2016 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// Print out text in s-expression format +// + +#include +#include +#include +#include +#include +#include + +namespace wasm { + +namespace { + +bool isFullForced() { + if (getenv("BINARYEN_PRINT_FULL")) { + return std::stoi(getenv("BINARYEN_PRINT_FULL")) != 0; + } + return false; +} + +std::ostream& printName(Name name, std::ostream& o) { + // we need to quote names if they have tricky chars + if (!name.str || !strpbrk(name.str, "()")) { + o << '$' << name.str; + } else { + o << "\"$" << name.str << '"'; + } + return o; +} + +static std::ostream& printLocal(Index index, Function* func, std::ostream& o) { + Name name; + if (func) { + name = func->getLocalNameOrDefault(index); + } + if (!name) { + name = Name::fromInt(index); + } + return printName(name, o); +} + +// Unlike the default format, tuple types in s-expressions should not have +// commas. +struct SExprType { + Type type; + SExprType(Type type) : type(type){}; +}; + +static std::ostream& operator<<(std::ostream& o, const SExprType& localType) { + Type type = localType.type; + if (type.isTuple()) { + o << '('; + auto sep = ""; + for (const auto& t : type) { + o << sep << t; + sep = " "; + } + o << ')'; + } else { + o << type; + } + return o; +} + +// Wrapper for printing signature names +struct SigName { + Signature sig; + SigName(Signature sig) : sig(sig) {} +}; + +std::ostream& operator<<(std::ostream& os, SigName sigName) { + auto printType = [&](Type type) { + if (type == Type::none) { + os << "none"; + } else { + auto sep = ""; + for (const auto& t : type) { + os << sep << t; + sep = "_"; + } + } + }; + + os << '$'; + printType(sigName.sig.params); + os << "_=>_"; + printType(sigName.sig.results); + return os; +} + +} // anonymous namespace + +// Printing "unreachable" as a instruction prefix type is not valid in wasm text +// format. Print something else to make it pass. +static Type forceConcrete(Type type) { + return type.isConcrete() ? type : Type::i32; +} + +// Prints the internal contents of an expression: everything but +// the children. +struct PrintExpressionContents + : public OverriddenVisitor { + Function* currFunction = nullptr; + std::ostream& o; + + PrintExpressionContents(Function* currFunction, std::ostream& o) + : currFunction(currFunction), o(o) {} + + void visitBlock(Block* curr) { + printMedium(o, "block"); + if (curr->name.is()) { + o << ' '; + printName(curr->name, o); + } + if (curr->type.isConcrete()) { + o << ' ' << ResultType(curr->type); + } + } + void visitIf(If* curr) { + printMedium(o, "if"); + if (curr->type.isConcrete()) { + o << ' ' << ResultType(curr->type); + } + } + void visitLoop(Loop* curr) { + printMedium(o, "loop"); + if (curr->name.is()) { + o << ' '; + printName(curr->name, o); + } + if (curr->type.isConcrete()) { + o << ' ' << ResultType(curr->type); + } + } + void visitBreak(Break* curr) { + if (curr->condition) { + printMedium(o, "br_if "); + } else { + printMedium(o, "br "); + } + printName(curr->name, o); + } + void visitSwitch(Switch* curr) { + printMedium(o, "br_table"); + for (auto& t : curr->targets) { + o << ' '; + printName(t, o); + } + o << ' '; + printName(curr->default_, o); + } + void visitCall(Call* curr) { + if (curr->isReturn) { + printMedium(o, "return_call "); + } else { + printMedium(o, "call "); + } + printName(curr->target, o); + } + void visitCallIndirect(CallIndirect* curr) { + if (curr->isReturn) { + printMedium(o, "return_call_indirect (type "); + } else { + printMedium(o, "call_indirect (type "); + } + o << SigName(curr->sig) << ')'; + } + void visitLocalGet(LocalGet* curr) { + printMedium(o, "local.get "); + printLocal(curr->index, currFunction, o); + } + void visitLocalSet(LocalSet* curr) { + if (curr->isTee()) { + printMedium(o, "local.tee "); + } else { + printMedium(o, "local.set "); + } + printLocal(curr->index, currFunction, o); + } + void visitGlobalGet(GlobalGet* curr) { + printMedium(o, "global.get "); + printName(curr->name, o); + } + void visitGlobalSet(GlobalSet* curr) { + printMedium(o, "global.set "); + printName(curr->name, o); + } + void visitLoad(Load* curr) { + prepareColor(o) << forceConcrete(curr->type); + if (curr->isAtomic) { + o << ".atomic"; + } + o << ".load"; + if (curr->type != Type::unreachable && + curr->bytes < curr->type.getByteSize()) { + if (curr->bytes == 1) { + o << '8'; + } else if (curr->bytes == 2) { + o << "16"; + } else if (curr->bytes == 4) { + o << "32"; + } else { + abort(); + } + o << (curr->signed_ ? "_s" : "_u"); + } + restoreNormalColor(o); + if (curr->offset) { + o << " offset=" << curr->offset; + } + if (curr->align != curr->bytes) { + o << " align=" << curr->align; + } + } + void visitStore(Store* curr) { + prepareColor(o) << forceConcrete(curr->valueType); + if (curr->isAtomic) { + o << ".atomic"; + } + o << ".store"; + if (curr->bytes < 4 || (curr->valueType == Type::i64 && curr->bytes < 8)) { + if (curr->bytes == 1) { + o << '8'; + } else if (curr->bytes == 2) { + o << "16"; + } else if (curr->bytes == 4) { + o << "32"; + } else { + abort(); + } + } + restoreNormalColor(o); + if (curr->offset) { + o << " offset=" << curr->offset; + } + if (curr->align != curr->bytes) { + o << " align=" << curr->align; + } + } + static void printRMWSize(std::ostream& o, Type type, uint8_t bytes) { + prepareColor(o) << forceConcrete(type) << ".atomic.rmw"; + if (type != Type::unreachable && bytes != type.getByteSize()) { + if (bytes == 1) { + o << '8'; + } else if (bytes == 2) { + o << "16"; + } else if (bytes == 4) { + o << "32"; + } else { + WASM_UNREACHABLE("invalid RMW byte length"); + } + } + o << '.'; + } + void visitAtomicRMW(AtomicRMW* curr) { + prepareColor(o); + printRMWSize(o, curr->type, curr->bytes); + switch (curr->op) { + case Add: + o << "add"; + break; + case Sub: + o << "sub"; + break; + case And: + o << "and"; + break; + case Or: + o << "or"; + break; + case Xor: + o << "xor"; + break; + case Xchg: + o << "xchg"; + break; + } + if (curr->type != Type::unreachable && + curr->bytes != curr->type.getByteSize()) { + o << "_u"; + } + restoreNormalColor(o); + if (curr->offset) { + o << " offset=" << curr->offset; + } + } + void visitAtomicCmpxchg(AtomicCmpxchg* curr) { + prepareColor(o); + printRMWSize(o, curr->type, curr->bytes); + o << "cmpxchg"; + if (curr->type != Type::unreachable && + curr->bytes != curr->type.getByteSize()) { + o << "_u"; + } + restoreNormalColor(o); + if (curr->offset) { + o << " offset=" << curr->offset; + } + } + void visitAtomicWait(AtomicWait* curr) { + prepareColor(o); + o << forceConcrete(curr->expectedType) << ".atomic.wait"; + if (curr->offset) { + o << " offset=" << curr->offset; + } + } + void visitAtomicNotify(AtomicNotify* curr) { + printMedium(o, "atomic.notify"); + if (curr->offset) { + o << " offset=" << curr->offset; + } + } + void visitAtomicFence(AtomicFence* curr) { printMedium(o, "atomic.fence"); } + void visitSIMDExtract(SIMDExtract* curr) { + prepareColor(o); + switch (curr->op) { + case ExtractLaneSVecI8x16: + o << "i8x16.extract_lane_s"; + break; + case ExtractLaneUVecI8x16: + o << "i8x16.extract_lane_u"; + break; + case ExtractLaneSVecI16x8: + o << "i16x8.extract_lane_s"; + break; + case ExtractLaneUVecI16x8: + o << "i16x8.extract_lane_u"; + break; + case ExtractLaneVecI32x4: + o << "i32x4.extract_lane"; + break; + case ExtractLaneVecI64x2: + o << "i64x2.extract_lane"; + break; + case ExtractLaneVecF32x4: + o << "f32x4.extract_lane"; + break; + case ExtractLaneVecF64x2: + o << "f64x2.extract_lane"; + break; + } + o << " " << int(curr->index); + } + void visitSIMDReplace(SIMDReplace* curr) { + prepareColor(o); + switch (curr->op) { + case ReplaceLaneVecI8x16: + o << "i8x16.replace_lane"; + break; + case ReplaceLaneVecI16x8: + o << "i16x8.replace_lane"; + break; + case ReplaceLaneVecI32x4: + o << "i32x4.replace_lane"; + break; + case ReplaceLaneVecI64x2: + o << "i64x2.replace_lane"; + break; + case ReplaceLaneVecF32x4: + o << "f32x4.replace_lane"; + break; + case ReplaceLaneVecF64x2: + o << "f64x2.replace_lane"; + break; + } + o << " " << int(curr->index); + } + void visitSIMDShuffle(SIMDShuffle* curr) { + prepareColor(o); + o << "v8x16.shuffle"; + for (uint8_t mask_index : curr->mask) { + o << " " << std::to_string(mask_index); + } + } + void visitSIMDTernary(SIMDTernary* curr) { + prepareColor(o); + switch (curr->op) { + case Bitselect: + o << "v128.bitselect"; + break; + case QFMAF32x4: + o << "f32x4.qfma"; + break; + case QFMSF32x4: + o << "f32x4.qfms"; + break; + case QFMAF64x2: + o << "f64x2.qfma"; + break; + case QFMSF64x2: + o << "f64x2.qfms"; + break; + } + } + void visitSIMDShift(SIMDShift* curr) { + prepareColor(o); + switch (curr->op) { + case ShlVecI8x16: + o << "i8x16.shl"; + break; + case ShrSVecI8x16: + o << "i8x16.shr_s"; + break; + case ShrUVecI8x16: + o << "i8x16.shr_u"; + break; + case ShlVecI16x8: + o << "i16x8.shl"; + break; + case ShrSVecI16x8: + o << "i16x8.shr_s"; + break; + case ShrUVecI16x8: + o << "i16x8.shr_u"; + break; + case ShlVecI32x4: + o << "i32x4.shl"; + break; + case ShrSVecI32x4: + o << "i32x4.shr_s"; + break; + case ShrUVecI32x4: + o << "i32x4.shr_u"; + break; + case ShlVecI64x2: + o << "i64x2.shl"; + break; + case ShrSVecI64x2: + o << "i64x2.shr_s"; + break; + case ShrUVecI64x2: + o << "i64x2.shr_u"; + break; + } + } + void visitSIMDLoad(SIMDLoad* curr) { + prepareColor(o); + switch (curr->op) { + case LoadSplatVec8x16: + o << "v8x16.load_splat"; + break; + case LoadSplatVec16x8: + o << "v16x8.load_splat"; + break; + case LoadSplatVec32x4: + o << "v32x4.load_splat"; + break; + case LoadSplatVec64x2: + o << "v64x2.load_splat"; + break; + case LoadExtSVec8x8ToVecI16x8: + o << "i16x8.load8x8_s"; + break; + case LoadExtUVec8x8ToVecI16x8: + o << "i16x8.load8x8_u"; + break; + case LoadExtSVec16x4ToVecI32x4: + o << "i32x4.load16x4_s"; + break; + case LoadExtUVec16x4ToVecI32x4: + o << "i32x4.load16x4_u"; + break; + case LoadExtSVec32x2ToVecI64x2: + o << "i64x2.load32x2_s"; + break; + case LoadExtUVec32x2ToVecI64x2: + o << "i64x2.load32x2_u"; + break; + case Load32Zero: + o << "v128.load32_zero"; + break; + case Load64Zero: + o << "v128.load64_zero"; + break; + } + restoreNormalColor(o); + if (curr->offset) { + o << " offset=" << curr->offset; + } + if (curr->align != curr->getMemBytes()) { + o << " align=" << curr->align; + } + } + void visitMemoryInit(MemoryInit* curr) { + prepareColor(o); + o << "memory.init " << curr->segment; + } + void visitDataDrop(DataDrop* curr) { + prepareColor(o); + o << "data.drop " << curr->segment; + } + void visitMemoryCopy(MemoryCopy* curr) { + prepareColor(o); + o << "memory.copy"; + } + void visitMemoryFill(MemoryFill* curr) { + prepareColor(o); + o << "memory.fill"; + } + void visitConst(Const* curr) { + o << curr->value.type << ".const " << curr->value; + } + void visitUnary(Unary* curr) { + prepareColor(o); + switch (curr->op) { + case ClzInt32: + o << "i32.clz"; + break; + case CtzInt32: + o << "i32.ctz"; + break; + case PopcntInt32: + o << "i32.popcnt"; + break; + case EqZInt32: + o << "i32.eqz"; + break; + case ClzInt64: + o << "i64.clz"; + break; + case CtzInt64: + o << "i64.ctz"; + break; + case PopcntInt64: + o << "i64.popcnt"; + break; + case EqZInt64: + o << "i64.eqz"; + break; + case NegFloat32: + o << "f32.neg"; + break; + case AbsFloat32: + o << "f32.abs"; + break; + case CeilFloat32: + o << "f32.ceil"; + break; + case FloorFloat32: + o << "f32.floor"; + break; + case TruncFloat32: + o << "f32.trunc"; + break; + case NearestFloat32: + o << "f32.nearest"; + break; + case SqrtFloat32: + o << "f32.sqrt"; + break; + case NegFloat64: + o << "f64.neg"; + break; + case AbsFloat64: + o << "f64.abs"; + break; + case CeilFloat64: + o << "f64.ceil"; + break; + case FloorFloat64: + o << "f64.floor"; + break; + case TruncFloat64: + o << "f64.trunc"; + break; + case NearestFloat64: + o << "f64.nearest"; + break; + case SqrtFloat64: + o << "f64.sqrt"; + break; + case ExtendSInt32: + o << "i64.extend_i32_s"; + break; + case ExtendUInt32: + o << "i64.extend_i32_u"; + break; + case WrapInt64: + o << "i32.wrap_i64"; + break; + case TruncSFloat32ToInt32: + o << "i32.trunc_f32_s"; + break; + case TruncSFloat32ToInt64: + o << "i64.trunc_f32_s"; + break; + case TruncUFloat32ToInt32: + o << "i32.trunc_f32_u"; + break; + case TruncUFloat32ToInt64: + o << "i64.trunc_f32_u"; + break; + case TruncSFloat64ToInt32: + o << "i32.trunc_f64_s"; + break; + case TruncSFloat64ToInt64: + o << "i64.trunc_f64_s"; + break; + case TruncUFloat64ToInt32: + o << "i32.trunc_f64_u"; + break; + case TruncUFloat64ToInt64: + o << "i64.trunc_f64_u"; + break; + case ReinterpretFloat32: + o << "i32.reinterpret_f32"; + break; + case ReinterpretFloat64: + o << "i64.reinterpret_f64"; + break; + case ConvertUInt32ToFloat32: + o << "f32.convert_i32_u"; + break; + case ConvertUInt32ToFloat64: + o << "f64.convert_i32_u"; + break; + case ConvertSInt32ToFloat32: + o << "f32.convert_i32_s"; + break; + case ConvertSInt32ToFloat64: + o << "f64.convert_i32_s"; + break; + case ConvertUInt64ToFloat32: + o << "f32.convert_i64_u"; + break; + case ConvertUInt64ToFloat64: + o << "f64.convert_i64_u"; + break; + case ConvertSInt64ToFloat32: + o << "f32.convert_i64_s"; + break; + case ConvertSInt64ToFloat64: + o << "f64.convert_i64_s"; + break; + case PromoteFloat32: + o << "f64.promote_f32"; + break; + case DemoteFloat64: + o << "f32.demote_f64"; + break; + case ReinterpretInt32: + o << "f32.reinterpret_i32"; + break; + case ReinterpretInt64: + o << "f64.reinterpret_i64"; + break; + case ExtendS8Int32: + o << "i32.extend8_s"; + break; + case ExtendS16Int32: + o << "i32.extend16_s"; + break; + case ExtendS8Int64: + o << "i64.extend8_s"; + break; + case ExtendS16Int64: + o << "i64.extend16_s"; + break; + case ExtendS32Int64: + o << "i64.extend32_s"; + break; + case TruncSatSFloat32ToInt32: + o << "i32.trunc_sat_f32_s"; + break; + case TruncSatUFloat32ToInt32: + o << "i32.trunc_sat_f32_u"; + break; + case TruncSatSFloat64ToInt32: + o << "i32.trunc_sat_f64_s"; + break; + case TruncSatUFloat64ToInt32: + o << "i32.trunc_sat_f64_u"; + break; + case TruncSatSFloat32ToInt64: + o << "i64.trunc_sat_f32_s"; + break; + case TruncSatUFloat32ToInt64: + o << "i64.trunc_sat_f32_u"; + break; + case TruncSatSFloat64ToInt64: + o << "i64.trunc_sat_f64_s"; + break; + case TruncSatUFloat64ToInt64: + o << "i64.trunc_sat_f64_u"; + break; + case SplatVecI8x16: + o << "i8x16.splat"; + break; + case SplatVecI16x8: + o << "i16x8.splat"; + break; + case SplatVecI32x4: + o << "i32x4.splat"; + break; + case SplatVecI64x2: + o << "i64x2.splat"; + break; + case SplatVecF32x4: + o << "f32x4.splat"; + break; + case SplatVecF64x2: + o << "f64x2.splat"; + break; + case NotVec128: + o << "v128.not"; + break; + case AbsVecI8x16: + o << "i8x16.abs"; + break; + case NegVecI8x16: + o << "i8x16.neg"; + break; + case AnyTrueVecI8x16: + o << "i8x16.any_true"; + break; + case AllTrueVecI8x16: + o << "i8x16.all_true"; + break; + case BitmaskVecI8x16: + o << "i8x16.bitmask"; + break; + case AbsVecI16x8: + o << "i16x8.abs"; + break; + case NegVecI16x8: + o << "i16x8.neg"; + break; + case AnyTrueVecI16x8: + o << "i16x8.any_true"; + break; + case AllTrueVecI16x8: + o << "i16x8.all_true"; + break; + case BitmaskVecI16x8: + o << "i16x8.bitmask"; + break; + case AbsVecI32x4: + o << "i32x4.abs"; + break; + case NegVecI32x4: + o << "i32x4.neg"; + break; + case AnyTrueVecI32x4: + o << "i32x4.any_true"; + break; + case AllTrueVecI32x4: + o << "i32x4.all_true"; + break; + case BitmaskVecI32x4: + o << "i32x4.bitmask"; + break; + case NegVecI64x2: + o << "i64x2.neg"; + break; + case AnyTrueVecI64x2: + o << "i64x2.any_true"; + break; + case AllTrueVecI64x2: + o << "i64x2.all_true"; + break; + case AbsVecF32x4: + o << "f32x4.abs"; + break; + case NegVecF32x4: + o << "f32x4.neg"; + break; + case SqrtVecF32x4: + o << "f32x4.sqrt"; + break; + case CeilVecF32x4: + o << "f32x4.ceil"; + break; + case FloorVecF32x4: + o << "f32x4.floor"; + break; + case TruncVecF32x4: + o << "f32x4.trunc"; + break; + case NearestVecF32x4: + o << "f32x4.nearest"; + break; + case AbsVecF64x2: + o << "f64x2.abs"; + break; + case NegVecF64x2: + o << "f64x2.neg"; + break; + case SqrtVecF64x2: + o << "f64x2.sqrt"; + break; + case CeilVecF64x2: + o << "f64x2.ceil"; + break; + case FloorVecF64x2: + o << "f64x2.floor"; + break; + case TruncVecF64x2: + o << "f64x2.trunc"; + break; + case NearestVecF64x2: + o << "f64x2.nearest"; + break; + case TruncSatSVecF32x4ToVecI32x4: + o << "i32x4.trunc_sat_f32x4_s"; + break; + case TruncSatUVecF32x4ToVecI32x4: + o << "i32x4.trunc_sat_f32x4_u"; + break; + case TruncSatSVecF64x2ToVecI64x2: + o << "i64x2.trunc_sat_f64x2_s"; + break; + case TruncSatUVecF64x2ToVecI64x2: + o << "i64x2.trunc_sat_f64x2_u"; + break; + case ConvertSVecI32x4ToVecF32x4: + o << "f32x4.convert_i32x4_s"; + break; + case ConvertUVecI32x4ToVecF32x4: + o << "f32x4.convert_i32x4_u"; + break; + case ConvertSVecI64x2ToVecF64x2: + o << "f64x2.convert_i64x2_s"; + break; + case ConvertUVecI64x2ToVecF64x2: + o << "f64x2.convert_i64x2_u"; + break; + case WidenLowSVecI8x16ToVecI16x8: + o << "i16x8.widen_low_i8x16_s"; + break; + case WidenHighSVecI8x16ToVecI16x8: + o << "i16x8.widen_high_i8x16_s"; + break; + case WidenLowUVecI8x16ToVecI16x8: + o << "i16x8.widen_low_i8x16_u"; + break; + case WidenHighUVecI8x16ToVecI16x8: + o << "i16x8.widen_high_i8x16_u"; + break; + case WidenLowSVecI16x8ToVecI32x4: + o << "i32x4.widen_low_i16x8_s"; + break; + case WidenHighSVecI16x8ToVecI32x4: + o << "i32x4.widen_high_i16x8_s"; + break; + case WidenLowUVecI16x8ToVecI32x4: + o << "i32x4.widen_low_i16x8_u"; + break; + case WidenHighUVecI16x8ToVecI32x4: + o << "i32x4.widen_high_i16x8_u"; + break; + case InvalidUnary: + WASM_UNREACHABLE("unvalid unary operator"); + } + } + void visitBinary(Binary* curr) { + prepareColor(o); + switch (curr->op) { + case AddInt32: + o << "i32.add"; + break; + case SubInt32: + o << "i32.sub"; + break; + case MulInt32: + o << "i32.mul"; + break; + case DivSInt32: + o << "i32.div_s"; + break; + case DivUInt32: + o << "i32.div_u"; + break; + case RemSInt32: + o << "i32.rem_s"; + break; + case RemUInt32: + o << "i32.rem_u"; + break; + case AndInt32: + o << "i32.and"; + break; + case OrInt32: + o << "i32.or"; + break; + case XorInt32: + o << "i32.xor"; + break; + case ShlInt32: + o << "i32.shl"; + break; + case ShrUInt32: + o << "i32.shr_u"; + break; + case ShrSInt32: + o << "i32.shr_s"; + break; + case RotLInt32: + o << "i32.rotl"; + break; + case RotRInt32: + o << "i32.rotr"; + break; + case EqInt32: + o << "i32.eq"; + break; + case NeInt32: + o << "i32.ne"; + break; + case LtSInt32: + o << "i32.lt_s"; + break; + case LtUInt32: + o << "i32.lt_u"; + break; + case LeSInt32: + o << "i32.le_s"; + break; + case LeUInt32: + o << "i32.le_u"; + break; + case GtSInt32: + o << "i32.gt_s"; + break; + case GtUInt32: + o << "i32.gt_u"; + break; + case GeSInt32: + o << "i32.ge_s"; + break; + case GeUInt32: + o << "i32.ge_u"; + break; + + case AddInt64: + o << "i64.add"; + break; + case SubInt64: + o << "i64.sub"; + break; + case MulInt64: + o << "i64.mul"; + break; + case DivSInt64: + o << "i64.div_s"; + break; + case DivUInt64: + o << "i64.div_u"; + break; + case RemSInt64: + o << "i64.rem_s"; + break; + case RemUInt64: + o << "i64.rem_u"; + break; + case AndInt64: + o << "i64.and"; + break; + case OrInt64: + o << "i64.or"; + break; + case XorInt64: + o << "i64.xor"; + break; + case ShlInt64: + o << "i64.shl"; + break; + case ShrUInt64: + o << "i64.shr_u"; + break; + case ShrSInt64: + o << "i64.shr_s"; + break; + case RotLInt64: + o << "i64.rotl"; + break; + case RotRInt64: + o << "i64.rotr"; + break; + case EqInt64: + o << "i64.eq"; + break; + case NeInt64: + o << "i64.ne"; + break; + case LtSInt64: + o << "i64.lt_s"; + break; + case LtUInt64: + o << "i64.lt_u"; + break; + case LeSInt64: + o << "i64.le_s"; + break; + case LeUInt64: + o << "i64.le_u"; + break; + case GtSInt64: + o << "i64.gt_s"; + break; + case GtUInt64: + o << "i64.gt_u"; + break; + case GeSInt64: + o << "i64.ge_s"; + break; + case GeUInt64: + o << "i64.ge_u"; + break; + + case AddFloat32: + o << "f32.add"; + break; + case SubFloat32: + o << "f32.sub"; + break; + case MulFloat32: + o << "f32.mul"; + break; + case DivFloat32: + o << "f32.div"; + break; + case CopySignFloat32: + o << "f32.copysign"; + break; + case MinFloat32: + o << "f32.min"; + break; + case MaxFloat32: + o << "f32.max"; + break; + case EqFloat32: + o << "f32.eq"; + break; + case NeFloat32: + o << "f32.ne"; + break; + case LtFloat32: + o << "f32.lt"; + break; + case LeFloat32: + o << "f32.le"; + break; + case GtFloat32: + o << "f32.gt"; + break; + case GeFloat32: + o << "f32.ge"; + break; + + case AddFloat64: + o << "f64.add"; + break; + case SubFloat64: + o << "f64.sub"; + break; + case MulFloat64: + o << "f64.mul"; + break; + case DivFloat64: + o << "f64.div"; + break; + case CopySignFloat64: + o << "f64.copysign"; + break; + case MinFloat64: + o << "f64.min"; + break; + case MaxFloat64: + o << "f64.max"; + break; + case EqFloat64: + o << "f64.eq"; + break; + case NeFloat64: + o << "f64.ne"; + break; + case LtFloat64: + o << "f64.lt"; + break; + case LeFloat64: + o << "f64.le"; + break; + case GtFloat64: + o << "f64.gt"; + break; + case GeFloat64: + o << "f64.ge"; + break; + + case EqVecI8x16: + o << "i8x16.eq"; + break; + case NeVecI8x16: + o << "i8x16.ne"; + break; + case LtSVecI8x16: + o << "i8x16.lt_s"; + break; + case LtUVecI8x16: + o << "i8x16.lt_u"; + break; + case GtSVecI8x16: + o << "i8x16.gt_s"; + break; + case GtUVecI8x16: + o << "i8x16.gt_u"; + break; + case LeSVecI8x16: + o << "i8x16.le_s"; + break; + case LeUVecI8x16: + o << "i8x16.le_u"; + break; + case GeSVecI8x16: + o << "i8x16.ge_s"; + break; + case GeUVecI8x16: + o << "i8x16.ge_u"; + break; + case EqVecI16x8: + o << "i16x8.eq"; + break; + case NeVecI16x8: + o << "i16x8.ne"; + break; + case LtSVecI16x8: + o << "i16x8.lt_s"; + break; + case LtUVecI16x8: + o << "i16x8.lt_u"; + break; + case GtSVecI16x8: + o << "i16x8.gt_s"; + break; + case GtUVecI16x8: + o << "i16x8.gt_u"; + break; + case LeSVecI16x8: + o << "i16x8.le_s"; + break; + case LeUVecI16x8: + o << "i16x8.le_u"; + break; + case GeSVecI16x8: + o << "i16x8.ge_s"; + break; + case GeUVecI16x8: + o << "i16x8.ge_u"; + break; + case EqVecI32x4: + o << "i32x4.eq"; + break; + case NeVecI32x4: + o << "i32x4.ne"; + break; + case LtSVecI32x4: + o << "i32x4.lt_s"; + break; + case LtUVecI32x4: + o << "i32x4.lt_u"; + break; + case GtSVecI32x4: + o << "i32x4.gt_s"; + break; + case GtUVecI32x4: + o << "i32x4.gt_u"; + break; + case LeSVecI32x4: + o << "i32x4.le_s"; + break; + case LeUVecI32x4: + o << "i32x4.le_u"; + break; + case GeSVecI32x4: + o << "i32x4.ge_s"; + break; + case GeUVecI32x4: + o << "i32x4.ge_u"; + break; + case EqVecF32x4: + o << "f32x4.eq"; + break; + case NeVecF32x4: + o << "f32x4.ne"; + break; + case LtVecF32x4: + o << "f32x4.lt"; + break; + case GtVecF32x4: + o << "f32x4.gt"; + break; + case LeVecF32x4: + o << "f32x4.le"; + break; + case GeVecF32x4: + o << "f32x4.ge"; + break; + case EqVecF64x2: + o << "f64x2.eq"; + break; + case NeVecF64x2: + o << "f64x2.ne"; + break; + case LtVecF64x2: + o << "f64x2.lt"; + break; + case GtVecF64x2: + o << "f64x2.gt"; + break; + case LeVecF64x2: + o << "f64x2.le"; + break; + case GeVecF64x2: + o << "f64x2.ge"; + break; + + case AndVec128: + o << "v128.and"; + break; + case OrVec128: + o << "v128.or"; + break; + case XorVec128: + o << "v128.xor"; + break; + case AndNotVec128: + o << "v128.andnot"; + break; + + case AddVecI8x16: + o << "i8x16.add"; + break; + case AddSatSVecI8x16: + o << "i8x16.add_saturate_s"; + break; + case AddSatUVecI8x16: + o << "i8x16.add_saturate_u"; + break; + case SubVecI8x16: + o << "i8x16.sub"; + break; + case SubSatSVecI8x16: + o << "i8x16.sub_saturate_s"; + break; + case SubSatUVecI8x16: + o << "i8x16.sub_saturate_u"; + break; + case MulVecI8x16: + o << "i8x16.mul"; + break; + case MinSVecI8x16: + o << "i8x16.min_s"; + break; + case MinUVecI8x16: + o << "i8x16.min_u"; + break; + case MaxSVecI8x16: + o << "i8x16.max_s"; + break; + case MaxUVecI8x16: + o << "i8x16.max_u"; + break; + case AvgrUVecI8x16: + o << "i8x16.avgr_u"; + break; + case AddVecI16x8: + o << "i16x8.add"; + break; + case AddSatSVecI16x8: + o << "i16x8.add_saturate_s"; + break; + case AddSatUVecI16x8: + o << "i16x8.add_saturate_u"; + break; + case SubVecI16x8: + o << "i16x8.sub"; + break; + case SubSatSVecI16x8: + o << "i16x8.sub_saturate_s"; + break; + case SubSatUVecI16x8: + o << "i16x8.sub_saturate_u"; + break; + case MulVecI16x8: + o << "i16x8.mul"; + break; + case MinSVecI16x8: + o << "i16x8.min_s"; + break; + case MinUVecI16x8: + o << "i16x8.min_u"; + break; + case MaxSVecI16x8: + o << "i16x8.max_s"; + break; + case MaxUVecI16x8: + o << "i16x8.max_u"; + break; + case AvgrUVecI16x8: + o << "i16x8.avgr_u"; + break; + case AddVecI32x4: + o << "i32x4.add"; + break; + case SubVecI32x4: + o << "i32x4.sub"; + break; + case MulVecI32x4: + o << "i32x4.mul"; + break; + case MinSVecI32x4: + o << "i32x4.min_s"; + break; + case MinUVecI32x4: + o << "i32x4.min_u"; + break; + case MaxSVecI32x4: + o << "i32x4.max_s"; + break; + case MaxUVecI32x4: + o << "i32x4.max_u"; + break; + case DotSVecI16x8ToVecI32x4: + o << "i32x4.dot_i16x8_s"; + break; + case AddVecI64x2: + o << "i64x2.add"; + break; + case SubVecI64x2: + o << "i64x2.sub"; + break; + case MulVecI64x2: + o << "i64x2.mul"; + break; + + case AddVecF32x4: + o << "f32x4.add"; + break; + case SubVecF32x4: + o << "f32x4.sub"; + break; + case MulVecF32x4: + o << "f32x4.mul"; + break; + case DivVecF32x4: + o << "f32x4.div"; + break; + case MinVecF32x4: + o << "f32x4.min"; + break; + case MaxVecF32x4: + o << "f32x4.max"; + break; + case PMinVecF32x4: + o << "f32x4.pmin"; + break; + case PMaxVecF32x4: + o << "f32x4.pmax"; + break; + case AddVecF64x2: + o << "f64x2.add"; + break; + case SubVecF64x2: + o << "f64x2.sub"; + break; + case MulVecF64x2: + o << "f64x2.mul"; + break; + case DivVecF64x2: + o << "f64x2.div"; + break; + case MinVecF64x2: + o << "f64x2.min"; + break; + case MaxVecF64x2: + o << "f64x2.max"; + break; + case PMinVecF64x2: + o << "f64x2.pmin"; + break; + case PMaxVecF64x2: + o << "f64x2.pmax"; + break; + + case NarrowSVecI16x8ToVecI8x16: + o << "i8x16.narrow_i16x8_s"; + break; + case NarrowUVecI16x8ToVecI8x16: + o << "i8x16.narrow_i16x8_u"; + break; + case NarrowSVecI32x4ToVecI16x8: + o << "i16x8.narrow_i32x4_s"; + break; + case NarrowUVecI32x4ToVecI16x8: + o << "i16x8.narrow_i32x4_u"; + break; + + case SwizzleVec8x16: + o << "v8x16.swizzle"; + break; + + case InvalidBinary: + WASM_UNREACHABLE("unvalid binary operator"); + } + restoreNormalColor(o); + } + void visitSelect(Select* curr) { + prepareColor(o) << "select"; + if (curr->type.isRef()) { + o << " (result " << curr->type << ')'; + } + } + void visitDrop(Drop* curr) { printMedium(o, "drop"); } + void visitReturn(Return* curr) { printMedium(o, "return"); } + void visitMemorySize(MemorySize* curr) { printMedium(o, "memory.size"); } + void visitMemoryGrow(MemoryGrow* curr) { printMedium(o, "memory.grow"); } + void visitRefNull(RefNull* curr) { + printMedium(o, "ref.null "); + o << curr->type.getHeapType(); + } + void visitRefIsNull(RefIsNull* curr) { printMedium(o, "ref.is_null"); } + void visitRefFunc(RefFunc* curr) { + printMedium(o, "ref.func "); + printName(curr->func, o); + } + void visitRefEq(RefEq* curr) { printMedium(o, "ref.eq"); } + void visitTry(Try* curr) { + printMedium(o, "try"); + if (curr->type.isConcrete()) { + o << ' ' << ResultType(curr->type); + } + } + void visitThrow(Throw* curr) { + printMedium(o, "throw "); + printName(curr->event, o); + } + void visitRethrow(Rethrow* curr) { printMedium(o, "rethrow"); } + void visitBrOnExn(BrOnExn* curr) { + printMedium(o, "br_on_exn "); + printName(curr->name, o); + o << " "; + printName(curr->event, o); + } + void visitNop(Nop* curr) { printMinor(o, "nop"); } + void visitUnreachable(Unreachable* curr) { printMinor(o, "unreachable"); } + void visitPop(Pop* curr) { + prepareColor(o) << "pop"; + for (auto type : curr->type) { + assert(type.isBasic() && "TODO: print and parse compound types"); + o << " " << type; + } + restoreNormalColor(o); + } + void visitTupleMake(TupleMake* curr) { printMedium(o, "tuple.make"); } + void visitTupleExtract(TupleExtract* curr) { + printMedium(o, "tuple.extract "); + o << curr->index; + } + void visitI31New(I31New* curr) { printMedium(o, "i31.new"); } + void visitI31Get(I31Get* curr) { + printMedium(o, curr->signed_ ? "i31.get_s" : "i31.get_u"); + } + void visitRefTest(RefTest* curr) { + printMedium(o, "ref.test"); + WASM_UNREACHABLE("TODO (gc): ref.test"); + } + void visitRefCast(RefCast* curr) { + printMedium(o, "ref.cast"); + WASM_UNREACHABLE("TODO (gc): ref.cast"); + } + void visitBrOnCast(BrOnCast* curr) { + printMedium(o, "br_on_cast"); + WASM_UNREACHABLE("TODO (gc): br_on_cast"); + } + void visitRttCanon(RttCanon* curr) { + printMedium(o, "rtt.canon"); + WASM_UNREACHABLE("TODO (gc): rtt.canon"); + } + void visitRttSub(RttSub* curr) { + printMedium(o, "rtt.sub"); + WASM_UNREACHABLE("TODO (gc): rtt.sub"); + } + void visitStructNew(StructNew* curr) { + WASM_UNREACHABLE("TODO (gc): struct.new"); + } + void visitStructGet(StructGet* curr) { + WASM_UNREACHABLE("TODO (gc): struct.get"); + } + void visitStructSet(StructSet* curr) { + printMedium(o, "struct.set"); + WASM_UNREACHABLE("TODO (gc): struct.set"); + } + void visitArrayNew(ArrayNew* curr) { + WASM_UNREACHABLE("TODO (gc): array.new"); + } + void visitArrayGet(ArrayGet* curr) { + WASM_UNREACHABLE("TODO (gc): array.get"); + } + void visitArraySet(ArraySet* curr) { + printMedium(o, "array.set"); + WASM_UNREACHABLE("TODO (gc): array.set"); + } + void visitArrayLen(ArrayLen* curr) { + printMedium(o, "array.len"); + WASM_UNREACHABLE("TODO (gc): array.len"); + } +}; + +// Prints an expression in s-expr format, including both the +// internal contents and the nested children. +struct PrintSExpression : public OverriddenVisitor { + std::ostream& o; + unsigned indent = 0; + + bool minify; + const char* maybeSpace; + const char* maybeNewLine; + + bool full = false; // whether to not elide nodes in output when possible + // (like implicit blocks) and to emit types + bool printStackIR = false; // whether to print stack IR if it is present + // (if false, and Stack IR is there, we just + // note it exists) + + Module* currModule = nullptr; + Function* currFunction = nullptr; + Function::DebugLocation lastPrintedLocation; + bool debugInfo; + + PrintSExpression(std::ostream& o) : o(o) { + setMinify(false); + if (!full) { + full = isFullForced(); + } + } + + void printDebugLocation(const Function::DebugLocation& location) { + if (lastPrintedLocation == location) { + return; + } + lastPrintedLocation = location; + auto fileName = currModule->debugInfoFileNames[location.fileIndex]; + o << ";;@ " << fileName << ":" << location.lineNumber << ":" + << location.columnNumber << '\n'; + doIndent(o, indent); + } + + void printDebugLocation(Expression* curr) { + if (currFunction) { + // show an annotation, if there is one + auto& debugLocations = currFunction->debugLocations; + auto iter = debugLocations.find(curr); + if (iter != debugLocations.end()) { + printDebugLocation(iter->second); + } + // show a binary position, if there is one + if (debugInfo) { + auto iter = currFunction->expressionLocations.find(curr); + if (iter != currFunction->expressionLocations.end()) { + Colors::grey(o); + o << ";; code offset: 0x" << std::hex << iter->second.start + << std::dec << '\n'; + restoreNormalColor(o); + doIndent(o, indent); + } + } + } + } + + void visit(Expression* curr) { + printDebugLocation(curr); + OverriddenVisitor::visit(curr); + } + + void setMinify(bool minify_) { + minify = minify_; + maybeSpace = minify ? "" : " "; + maybeNewLine = minify ? "" : "\n"; + } + + void setFull(bool full_) { full = full_; } + + void setPrintStackIR(bool printStackIR_) { printStackIR = printStackIR_; } + + void setDebugInfo(bool debugInfo_) { debugInfo = debugInfo_; } + + void incIndent() { + if (minify) { + return; + } + o << '\n'; + indent++; + } + void decIndent() { + if (!minify) { + assert(indent > 0); + indent--; + doIndent(o, indent); + } + o << ')'; + } + void printFullLine(Expression* expression) { + if (!minify) { + doIndent(o, indent); + } + if (full) { + o << "[" << expression->type << "] "; + } + visit(expression); + o << maybeNewLine; + } + + // loop, if, and try can contain implicit blocks. But they are not needed to + // be printed in some cases. + void maybePrintImplicitBlock(Expression* curr, bool allowMultipleInsts) { + auto block = curr->dynCast(); + if (!full && block && block->name.isNull() && + (allowMultipleInsts || block->list.size() == 1)) { + for (auto expression : block->list) { + printFullLine(expression); + } + } else { + printFullLine(curr); + } + } + + void visitBlock(Block* curr) { + // special-case Block, because Block nesting (in their first element) can be + // incredibly deep + std::vector stack; + while (1) { + if (stack.size() > 0) { + doIndent(o, indent); + printDebugLocation(curr); + } + stack.push_back(curr); + if (full) { + o << "[" << curr->type << "] "; + } + o << '('; + PrintExpressionContents(currFunction, o).visit(curr); + incIndent(); + if (curr->list.size() > 0 && curr->list[0]->is()) { + // recurse into the first element + curr = curr->list[0]->cast(); + continue; + } else { + break; // that's all we can recurse, start to unwind + } + } + auto* top = stack.back(); + while (stack.size() > 0) { + curr = stack.back(); + stack.pop_back(); + auto& list = curr->list; + for (size_t i = 0; i < list.size(); i++) { + if (curr != top && i == 0) { + // one of the block recursions we already handled + decIndent(); + if (full) { + o << " ;; end block"; + auto* child = list[0]->cast(); + if (child->name.is()) { + o << ' ' << child->name; + } + } + o << '\n'; + continue; + } + printFullLine(list[i]); + } + } + decIndent(); + if (full) { + o << " ;; end block"; + if (curr->name.is()) { + o << ' ' << curr->name; + } + } + } + void visitIf(If* curr) { + o << '('; + PrintExpressionContents(currFunction, o).visit(curr); + incIndent(); + printFullLine(curr->condition); + maybePrintImplicitBlock(curr->ifTrue, false); + if (curr->ifFalse) { + maybePrintImplicitBlock(curr->ifFalse, false); + } + decIndent(); + if (full) { + o << " ;; end if"; + } + } + void visitLoop(Loop* curr) { + o << '('; + PrintExpressionContents(currFunction, o).visit(curr); + incIndent(); + maybePrintImplicitBlock(curr->body, true); + decIndent(); + if (full) { + o << " ;; end loop"; + if (curr->name.is()) { + o << ' ' << curr->name; + } + } + } + void visitBreak(Break* curr) { + o << '('; + PrintExpressionContents(currFunction, o).visit(curr); + if (curr->condition) { + incIndent(); + } else { + if (!curr->value || curr->value->is()) { + // avoid a new line just for the parens + o << ')'; + return; + } + incIndent(); + } + if (curr->value && !curr->value->is()) { + printFullLine(curr->value); + } + if (curr->condition) { + printFullLine(curr->condition); + } + decIndent(); + } + void visitSwitch(Switch* curr) { + o << '('; + PrintExpressionContents(currFunction, o).visit(curr); + incIndent(); + if (curr->value && !curr->value->is()) { + printFullLine(curr->value); + } + printFullLine(curr->condition); + decIndent(); + } + + template void printCallOperands(CallBase* curr) { + if (curr->operands.size() > 0) { + incIndent(); + for (auto operand : curr->operands) { + printFullLine(operand); + } + decIndent(); + } else { + o << ')'; + } + } + + void visitCall(Call* curr) { + o << '('; + PrintExpressionContents(currFunction, o).visit(curr); + printCallOperands(curr); + } + void visitCallIndirect(CallIndirect* curr) { + o << '('; + PrintExpressionContents(currFunction, o).visit(curr); + incIndent(); + for (auto operand : curr->operands) { + printFullLine(operand); + } + printFullLine(curr->target); + decIndent(); + } + void visitLocalGet(LocalGet* curr) { + o << '('; + PrintExpressionContents(currFunction, o).visit(curr); + o << ')'; + } + void visitLocalSet(LocalSet* curr) { + o << '('; + PrintExpressionContents(currFunction, o).visit(curr); + incIndent(); + printFullLine(curr->value); + decIndent(); + } + void visitGlobalGet(GlobalGet* curr) { + o << '('; + PrintExpressionContents(currFunction, o).visit(curr); + o << ')'; + } + void visitGlobalSet(GlobalSet* curr) { + o << '('; + PrintExpressionContents(currFunction, o).visit(curr); + incIndent(); + printFullLine(curr->value); + decIndent(); + } + void visitLoad(Load* curr) { + o << '('; + PrintExpressionContents(currFunction, o).visit(curr); + incIndent(); + printFullLine(curr->ptr); + decIndent(); + } + void visitStore(Store* curr) { + o << '('; + PrintExpressionContents(currFunction, o).visit(curr); + incIndent(); + printFullLine(curr->ptr); + printFullLine(curr->value); + decIndent(); + } + void visitAtomicRMW(AtomicRMW* curr) { + o << '('; + PrintExpressionContents(currFunction, o).visit(curr); + incIndent(); + printFullLine(curr->ptr); + printFullLine(curr->value); + decIndent(); + } + void visitAtomicCmpxchg(AtomicCmpxchg* curr) { + o << '('; + PrintExpressionContents(currFunction, o).visit(curr); + incIndent(); + printFullLine(curr->ptr); + printFullLine(curr->expected); + printFullLine(curr->replacement); + decIndent(); + } + void visitAtomicWait(AtomicWait* curr) { + o << '('; + PrintExpressionContents(currFunction, o).visit(curr); + restoreNormalColor(o); + incIndent(); + printFullLine(curr->ptr); + printFullLine(curr->expected); + printFullLine(curr->timeout); + decIndent(); + } + void visitAtomicNotify(AtomicNotify* curr) { + o << '('; + PrintExpressionContents(currFunction, o).visit(curr); + incIndent(); + printFullLine(curr->ptr); + printFullLine(curr->notifyCount); + decIndent(); + } + void visitAtomicFence(AtomicFence* curr) { + o << '('; + PrintExpressionContents(currFunction, o).visit(curr); + o << ')'; + } + void visitSIMDExtract(SIMDExtract* curr) { + o << '('; + PrintExpressionContents(currFunction, o).visit(curr); + incIndent(); + printFullLine(curr->vec); + decIndent(); + } + void visitSIMDReplace(SIMDReplace* curr) { + o << '('; + PrintExpressionContents(currFunction, o).visit(curr); + incIndent(); + printFullLine(curr->vec); + printFullLine(curr->value); + decIndent(); + } + void visitSIMDShuffle(SIMDShuffle* curr) { + o << '('; + PrintExpressionContents(currFunction, o).visit(curr); + incIndent(); + printFullLine(curr->left); + printFullLine(curr->right); + decIndent(); + } + void visitSIMDTernary(SIMDTernary* curr) { + o << '('; + PrintExpressionContents(currFunction, o).visit(curr); + incIndent(); + printFullLine(curr->a); + printFullLine(curr->b); + printFullLine(curr->c); + decIndent(); + } + void visitSIMDShift(SIMDShift* curr) { + o << '('; + PrintExpressionContents(currFunction, o).visit(curr); + incIndent(); + printFullLine(curr->vec); + printFullLine(curr->shift); + decIndent(); + } + void visitSIMDLoad(SIMDLoad* curr) { + o << '('; + PrintExpressionContents(currFunction, o).visit(curr); + incIndent(); + printFullLine(curr->ptr); + decIndent(); + } + void visitMemoryInit(MemoryInit* curr) { + o << '('; + PrintExpressionContents(currFunction, o).visit(curr); + incIndent(); + printFullLine(curr->dest); + printFullLine(curr->offset); + printFullLine(curr->size); + decIndent(); + } + void visitDataDrop(DataDrop* curr) { + o << '('; + PrintExpressionContents(currFunction, o).visit(curr); + o << ')'; + } + void visitMemoryCopy(MemoryCopy* curr) { + o << '('; + PrintExpressionContents(currFunction, o).visit(curr); + incIndent(); + printFullLine(curr->dest); + printFullLine(curr->source); + printFullLine(curr->size); + decIndent(); + } + void visitMemoryFill(MemoryFill* curr) { + o << '('; + PrintExpressionContents(currFunction, o).visit(curr); + incIndent(); + printFullLine(curr->dest); + printFullLine(curr->value); + printFullLine(curr->size); + decIndent(); + } + void visitConst(Const* curr) { + o << '('; + PrintExpressionContents(currFunction, o).visit(curr); + o << ')'; + } + void visitUnary(Unary* curr) { + o << '('; + PrintExpressionContents(currFunction, o).visit(curr); + incIndent(); + printFullLine(curr->value); + decIndent(); + } + void visitBinary(Binary* curr) { + o << '('; + PrintExpressionContents(currFunction, o).visit(curr); + incIndent(); + printFullLine(curr->left); + printFullLine(curr->right); + decIndent(); + } + void visitSelect(Select* curr) { + o << '('; + PrintExpressionContents(currFunction, o).visit(curr); + incIndent(); + printFullLine(curr->ifTrue); + printFullLine(curr->ifFalse); + printFullLine(curr->condition); + decIndent(); + } + void visitDrop(Drop* curr) { + o << '('; + PrintExpressionContents(currFunction, o).visit(curr); + incIndent(); + printFullLine(curr->value); + decIndent(); + } + void visitReturn(Return* curr) { + o << '('; + PrintExpressionContents(currFunction, o).visit(curr); + if (!curr->value) { + // avoid a new line just for the parens + o << ')'; + return; + } + incIndent(); + printFullLine(curr->value); + decIndent(); + } + void visitMemorySize(MemorySize* curr) { + o << '('; + PrintExpressionContents(currFunction, o).visit(curr); + o << ')'; + } + void visitMemoryGrow(MemoryGrow* curr) { + o << '('; + PrintExpressionContents(currFunction, o).visit(curr); + incIndent(); + printFullLine(curr->delta); + decIndent(); + } + void visitRefNull(RefNull* curr) { + o << '('; + PrintExpressionContents(currFunction, o).visit(curr); + o << ')'; + } + void visitRefIsNull(RefIsNull* curr) { + o << '('; + PrintExpressionContents(currFunction, o).visit(curr); + incIndent(); + printFullLine(curr->value); + decIndent(); + } + void visitRefFunc(RefFunc* curr) { + o << '('; + PrintExpressionContents(currFunction, o).visit(curr); + o << ')'; + } + void visitRefEq(RefEq* curr) { + o << '('; + PrintExpressionContents(currFunction, o).visit(curr); + incIndent(); + printFullLine(curr->left); + printFullLine(curr->right); + decIndent(); + } + // try-catch-end is written in the folded wat format as + // (try + // (do + // ... + // ) + // (catch + // ... + // ) + // ) + // The parenthesis wrapping 'catch' is just a syntax and does not affect + // nested depths of instructions within. + void visitTry(Try* curr) { + o << '('; + PrintExpressionContents(currFunction, o).visit(curr); + incIndent(); + doIndent(o, indent); + o << "(do"; + incIndent(); + maybePrintImplicitBlock(curr->body, true); + decIndent(); + o << "\n"; + doIndent(o, indent); + o << "(catch"; + incIndent(); + maybePrintImplicitBlock(curr->catchBody, true); + decIndent(); + o << "\n"; + decIndent(); + if (full) { + o << " ;; end try"; + } + } + void visitThrow(Throw* curr) { + o << '('; + PrintExpressionContents(currFunction, o).visit(curr); + incIndent(); + for (auto operand : curr->operands) { + printFullLine(operand); + } + decIndent(); + } + void visitRethrow(Rethrow* curr) { + o << '('; + PrintExpressionContents(currFunction, o).visit(curr); + incIndent(); + printFullLine(curr->exnref); + decIndent(); + } + void visitBrOnExn(BrOnExn* curr) { + o << '('; + PrintExpressionContents(currFunction, o).visit(curr); + incIndent(); + printFullLine(curr->exnref); + decIndent(); + } + void visitNop(Nop* curr) { + o << '('; + PrintExpressionContents(currFunction, o).visit(curr); + o << ')'; + } + void visitUnreachable(Unreachable* curr) { + o << '('; + PrintExpressionContents(currFunction, o).visit(curr); + o << ')'; + } + void visitPop(Pop* curr) { + o << '('; + PrintExpressionContents(currFunction, o).visit(curr); + o << ')'; + } + void visitTupleMake(TupleMake* curr) { + o << '('; + PrintExpressionContents(currFunction, o).visit(curr); + incIndent(); + for (auto operand : curr->operands) { + printFullLine(operand); + } + decIndent(); + } + void visitTupleExtract(TupleExtract* curr) { + o << '('; + PrintExpressionContents(currFunction, o).visit(curr); + incIndent(); + printFullLine(curr->tuple); + decIndent(); + } + void visitI31New(I31New* curr) { + o << '('; + PrintExpressionContents(currFunction, o).visit(curr); + incIndent(); + printFullLine(curr->value); + decIndent(); + } + void visitI31Get(I31Get* curr) { + o << '('; + PrintExpressionContents(currFunction, o).visit(curr); + incIndent(); + printFullLine(curr->i31); + decIndent(); + } + void visitRefTest(RefTest* curr) { + o << '('; + PrintExpressionContents(currFunction, o).visit(curr); + WASM_UNREACHABLE("TODO (gc): ref.test"); + } + void visitRefCast(RefCast* curr) { + o << '('; + PrintExpressionContents(currFunction, o).visit(curr); + WASM_UNREACHABLE("TODO (gc): ref.cast"); + } + void visitBrOnCast(BrOnCast* curr) { + o << '('; + PrintExpressionContents(currFunction, o).visit(curr); + WASM_UNREACHABLE("TODO (gc): br_on_cast"); + } + void visitRttCanon(RttCanon* curr) { + o << '('; + PrintExpressionContents(currFunction, o).visit(curr); + WASM_UNREACHABLE("TODO (gc): rtt.canon"); + } + void visitRttSub(RttSub* curr) { + o << '('; + PrintExpressionContents(currFunction, o).visit(curr); + WASM_UNREACHABLE("TODO (gc): rtt.sub"); + } + void visitStructNew(StructNew* curr) { + o << '('; + PrintExpressionContents(currFunction, o).visit(curr); + WASM_UNREACHABLE("TODO (gc): struct.new"); + } + void visitStructGet(StructGet* curr) { + o << '('; + PrintExpressionContents(currFunction, o).visit(curr); + WASM_UNREACHABLE("TODO (gc): struct.get"); + } + void visitStructSet(StructSet* curr) { + o << '('; + PrintExpressionContents(currFunction, o).visit(curr); + WASM_UNREACHABLE("TODO (gc): struct.set"); + } + void visitArrayNew(ArrayNew* curr) { + o << '('; + PrintExpressionContents(currFunction, o).visit(curr); + WASM_UNREACHABLE("TODO (gc): array.new"); + } + void visitArrayGet(ArrayGet* curr) { + o << '('; + PrintExpressionContents(currFunction, o).visit(curr); + WASM_UNREACHABLE("TODO (gc): array.get"); + } + void visitArraySet(ArraySet* curr) { + o << '('; + PrintExpressionContents(currFunction, o).visit(curr); + WASM_UNREACHABLE("TODO (gc): array.set"); + } + void visitArrayLen(ArrayLen* curr) { + o << '('; + PrintExpressionContents(currFunction, o).visit(curr); + WASM_UNREACHABLE("TODO (gc): array.len"); + } + // Module-level visitors + void handleSignature(Signature curr, Name* funcName = nullptr) { + o << "(func"; + if (funcName) { + o << " $" << *funcName; + } + if (curr.params.size() > 0) { + o << maybeSpace; + o << ParamType(curr.params); + } + if (curr.results.size() > 0) { + o << maybeSpace; + o << ResultType(curr.results); + } + o << ")"; + } + void visitExport(Export* curr) { + o << '('; + printMedium(o, "export "); + printText(o, curr->name.str) << " ("; + switch (curr->kind) { + case ExternalKind::Function: + o << "func"; + break; + case ExternalKind::Table: + o << "table"; + break; + case ExternalKind::Memory: + o << "memory"; + break; + case ExternalKind::Global: + o << "global"; + break; + case ExternalKind::Event: + o << "event"; + break; + case ExternalKind::Invalid: + WASM_UNREACHABLE("invalid ExternalKind"); + } + o << ' '; + printName(curr->value, o) << "))"; + } + void emitImportHeader(Importable* curr) { + printMedium(o, "import "); + printText(o, curr->module.str) << ' '; + printText(o, curr->base.str) << ' '; + } + void visitGlobal(Global* curr) { + if (curr->imported()) { + visitImportedGlobal(curr); + } else { + visitDefinedGlobal(curr); + } + } + void emitGlobalType(Global* curr) { + if (curr->mutable_) { + o << "(mut " << SExprType(curr->type) << ')'; + } else { + o << SExprType(curr->type); + } + } + void visitImportedGlobal(Global* curr) { + doIndent(o, indent); + o << '('; + emitImportHeader(curr); + o << "(global "; + printName(curr->name, o) << ' '; + emitGlobalType(curr); + o << "))" << maybeNewLine; + } + void visitDefinedGlobal(Global* curr) { + doIndent(o, indent); + o << '('; + printMedium(o, "global "); + printName(curr->name, o) << ' '; + emitGlobalType(curr); + o << ' '; + visit(curr->init); + o << ')'; + o << maybeNewLine; + } + void visitFunction(Function* curr) { + if (curr->imported()) { + visitImportedFunction(curr); + } else { + visitDefinedFunction(curr); + } + } + void visitImportedFunction(Function* curr) { + doIndent(o, indent); + currFunction = curr; + lastPrintedLocation = {0, 0, 0}; + o << '('; + emitImportHeader(curr); + handleSignature(curr->sig, &curr->name); + o << ')'; + o << maybeNewLine; + } + void visitDefinedFunction(Function* curr) { + doIndent(o, indent); + currFunction = curr; + lastPrintedLocation = {0, 0, 0}; + if (currFunction->prologLocation.size()) { + printDebugLocation(*currFunction->prologLocation.begin()); + } + o << '('; + printMajor(o, "func "); + printName(curr->name, o); + if (!printStackIR && curr->stackIR && !minify) { + o << " (; has Stack IR ;)"; + } + if (curr->sig.params.size() > 0) { + Index i = 0; + for (const auto& param : curr->sig.params) { + o << maybeSpace; + o << '('; + printMinor(o, "param "); + printLocal(i, currFunction, o); + o << ' ' << param << ')'; + ++i; + } + } + if (curr->sig.results != Type::none) { + o << maybeSpace; + o << ResultType(curr->sig.results); + } + incIndent(); + for (size_t i = curr->getVarIndexBase(); i < curr->getNumLocals(); i++) { + doIndent(o, indent); + o << '('; + printMinor(o, "local "); + printLocal(i, currFunction, o) + << ' ' << SExprType(curr->getLocalType(i)) << ')'; + o << maybeNewLine; + } + // Print the body. + if (!printStackIR || !curr->stackIR) { + // It is ok to emit a block here, as a function can directly contain a + // list, even if our ast avoids that for simplicity. We can just do that + // optimization here.. + if (!full && curr->body->is() && + curr->body->cast()->name.isNull()) { + Block* block = curr->body->cast(); + for (auto item : block->list) { + printFullLine(item); + } + } else { + printFullLine(curr->body); + } + } else { + // Print the stack IR. + WasmPrinter::printStackIR(curr->stackIR.get(), o, curr); + } + if (currFunction->epilogLocation.size() && + lastPrintedLocation != *currFunction->epilogLocation.begin()) { + // Print last debug location: mix of decIndent and printDebugLocation + // logic. + doIndent(o, indent); + if (!minify) { + indent--; + } + printDebugLocation(*currFunction->epilogLocation.begin()); + o << ')'; + } else { + decIndent(); + } + o << maybeNewLine; + } + void visitEvent(Event* curr) { + if (curr->imported()) { + visitImportedEvent(curr); + } else { + visitDefinedEvent(curr); + } + } + void visitImportedEvent(Event* curr) { + doIndent(o, indent); + o << '('; + emitImportHeader(curr); + o << "(event "; + printName(curr->name, o); + o << maybeSpace << "(attr " << curr->attribute << ')' << maybeSpace; + o << ParamType(curr->sig.params); + o << "))"; + o << maybeNewLine; + } + void visitDefinedEvent(Event* curr) { + doIndent(o, indent); + o << '('; + printMedium(o, "event "); + printName(curr->name, o); + o << maybeSpace << "(attr " << curr->attribute << ')' << maybeSpace; + o << ParamType(curr->sig.params); + o << ")" << maybeNewLine; + } + void printTableHeader(Table* curr) { + o << '('; + printMedium(o, "table") << ' '; + printName(curr->name, o) << ' '; + o << curr->initial; + if (curr->hasMax()) { + o << ' ' << curr->max; + } + o << " funcref)"; + } + void visitTable(Table* curr) { + if (!curr->exists) { + return; + } + if (curr->imported()) { + doIndent(o, indent); + o << '('; + emitImportHeader(curr); + printTableHeader(&currModule->table); + o << ')' << maybeNewLine; + } else { + doIndent(o, indent); + printTableHeader(curr); + o << maybeNewLine; + } + for (auto& segment : curr->segments) { + // Don't print empty segments + if (segment.data.empty()) { + continue; + } + doIndent(o, indent); + o << '('; + printMajor(o, "elem "); + visit(segment.offset); + for (auto name : segment.data) { + o << ' '; + printName(name, o); + } + o << ')' << maybeNewLine; + } + } + void printMemoryHeader(Memory* curr) { + o << '('; + printMedium(o, "memory") << ' '; + printName(curr->name, o) << ' '; + if (curr->shared) { + o << '('; + printMedium(o, "shared "); + } + if (curr->is64()) { + o << "i64 "; + } + o << curr->initial; + if (curr->hasMax()) { + o << ' ' << curr->max; + } + if (curr->shared) { + o << ")"; + } + o << ")"; + } + void visitMemory(Memory* curr) { + if (!curr->exists) { + return; + } + if (curr->imported()) { + doIndent(o, indent); + o << '('; + emitImportHeader(curr); + printMemoryHeader(&currModule->memory); + o << ')' << maybeNewLine; + } else { + doIndent(o, indent); + printMemoryHeader(curr); + o << '\n'; + } + for (auto segment : curr->segments) { + doIndent(o, indent); + o << '('; + printMajor(o, "data "); + if (segment.isPassive) { + printMedium(o, "passive"); + } else { + visit(segment.offset); + } + o << " \""; + for (size_t i = 0; i < segment.data.size(); i++) { + unsigned char c = segment.data[i]; + switch (c) { + case '\n': + o << "\\n"; + break; + case '\r': + o << "\\0d"; + break; + case '\t': + o << "\\t"; + break; + case '\f': + o << "\\0c"; + break; + case '\b': + o << "\\08"; + break; + case '\\': + o << "\\\\"; + break; + case '"': + o << "\\\""; + break; + case '\'': + o << "\\'"; + break; + default: { + if (c >= 32 && c < 127) { + o << c; + } else { + o << std::hex << '\\' << (c / 16) << (c % 16) << std::dec; + } + } + } + } + o << "\")" << maybeNewLine; + } + } + void printDylinkSection(const std::unique_ptr& dylinkSection) { + doIndent(o, indent) << ";; dylink section\n"; + doIndent(o, indent) << ";; memorysize: " << dylinkSection->memorySize + << '\n'; + doIndent(o, indent) << ";; memoryalignment: " + << dylinkSection->memoryAlignment << '\n'; + doIndent(o, indent) << ";; tablesize: " << dylinkSection->tableSize + << '\n'; + doIndent(o, indent) << ";; tablealignment: " + << dylinkSection->tableAlignment << '\n'; + for (auto& neededDynlib : dylinkSection->neededDynlibs) { + doIndent(o, indent) << ";; needed dynlib: " << neededDynlib << '\n'; + } + } + void visitModule(Module* curr) { + currModule = curr; + o << '('; + printMajor(o, "module"); + if (curr->name.is()) { + o << ' '; + printName(curr->name, o); + } + incIndent(); + std::vector signatures; + std::unordered_map indices; + ModuleUtils::collectSignatures(*curr, signatures, indices); + for (auto sig : signatures) { + doIndent(o, indent); + o << '('; + printMedium(o, "type") << ' '; + o << SigName(sig) << ' '; + handleSignature(sig); + o << ")" << maybeNewLine; + } + ModuleUtils::iterImportedMemories( + *curr, [&](Memory* memory) { visitMemory(memory); }); + ModuleUtils::iterImportedTables(*curr, + [&](Table* table) { visitTable(table); }); + ModuleUtils::iterImportedGlobals( + *curr, [&](Global* global) { visitGlobal(global); }); + ModuleUtils::iterImportedFunctions( + *curr, [&](Function* func) { visitFunction(func); }); + ModuleUtils::iterImportedEvents(*curr, + [&](Event* event) { visitEvent(event); }); + ModuleUtils::iterDefinedMemories( + *curr, [&](Memory* memory) { visitMemory(memory); }); + ModuleUtils::iterDefinedTables(*curr, + [&](Table* table) { visitTable(table); }); + ModuleUtils::iterDefinedGlobals( + *curr, [&](Global* global) { visitGlobal(global); }); + ModuleUtils::iterDefinedEvents(*curr, + [&](Event* event) { visitEvent(event); }); + for (auto& child : curr->exports) { + doIndent(o, indent); + visitExport(child.get()); + o << maybeNewLine; + } + if (curr->start.is()) { + doIndent(o, indent); + o << '('; + printMedium(o, "start") << ' '; + printName(curr->start, o) << ')'; + o << maybeNewLine; + } + ModuleUtils::iterDefinedFunctions( + *curr, [&](Function* func) { visitFunction(func); }); + if (curr->dylinkSection) { + printDylinkSection(curr->dylinkSection); + } + for (auto& section : curr->userSections) { + doIndent(o, indent); + o << ";; custom section \"" << section.name << "\", size " + << section.data.size(); + bool isPrintable = true; + for (auto c : section.data) { + if (!isprint(static_cast(c))) { + isPrintable = false; + break; + } + } + if (isPrintable) { + o << ", contents: "; + // std::quoted is not available in all the supported compilers yet. + o << '"'; + for (auto c : section.data) { + if (c == '\\' || c == '"') { + o << '\\'; + } + o << c; + } + o << '"'; + } + o << maybeNewLine; + } + decIndent(); + o << maybeNewLine; + currModule = nullptr; + } +}; + +// Prints out a module +class Printer : public Pass { +protected: + std::ostream& o; + +public: + Printer() : o(std::cout) {} + Printer(std::ostream* o) : o(*o) {} + + bool modifiesBinaryenIR() override { return false; } + + void run(PassRunner* runner, Module* module) override { + PrintSExpression print(o); + print.setDebugInfo(runner->options.debugInfo); + print.visitModule(module); + } +}; + +Pass* createPrinterPass() { return new Printer(); } + +// Prints out a minified module + +class MinifiedPrinter : public Printer { +public: + MinifiedPrinter() = default; + MinifiedPrinter(std::ostream* o) : Printer(o) {} + + void run(PassRunner* runner, Module* module) override { + PrintSExpression print(o); + print.setMinify(true); + print.setDebugInfo(runner->options.debugInfo); + print.visitModule(module); + } +}; + +Pass* createMinifiedPrinterPass() { return new MinifiedPrinter(); } + +// Prints out a module withough elision, i.e., the full ast + +class FullPrinter : public Printer { +public: + FullPrinter() = default; + FullPrinter(std::ostream* o) : Printer(o) {} + + void run(PassRunner* runner, Module* module) override { + PrintSExpression print(o); + print.setFull(true); + print.setDebugInfo(runner->options.debugInfo); + print.visitModule(module); + } +}; + +Pass* createFullPrinterPass() { return new FullPrinter(); } + +// Print Stack IR (if present) + +class PrintStackIR : public Printer { +public: + PrintStackIR() = default; + PrintStackIR(std::ostream* o) : Printer(o) {} + + void run(PassRunner* runner, Module* module) override { + PrintSExpression print(o); + print.setDebugInfo(runner->options.debugInfo); + print.setPrintStackIR(true); + print.visitModule(module); + } +}; + +Pass* createPrintStackIRPass() { return new PrintStackIR(); } + +// Print individual expressions + +std::ostream& WasmPrinter::printModule(Module* module, std::ostream& o) { + PassRunner runner(module); + Printer(&o).run(&runner, module); + return o; +} + +std::ostream& WasmPrinter::printModule(Module* module) { + return printModule(module, std::cout); +} + +std::ostream& WasmPrinter::printExpression(Expression* expression, + std::ostream& o, + bool minify, + bool full) { + if (!expression) { + o << "(null expression)"; + return o; + } + PrintSExpression print(o); + print.setMinify(minify); + if (full || isFullForced()) { + print.setFull(true); + o << "[" << expression->type << "] "; + } + print.visit(expression); + return o; +} + +std::ostream& +WasmPrinter::printStackInst(StackInst* inst, std::ostream& o, Function* func) { + switch (inst->op) { + case StackInst::Basic: { + PrintExpressionContents(func, o).visit(inst->origin); + break; + } + case StackInst::BlockBegin: + case StackInst::IfBegin: + case StackInst::LoopBegin: + case StackInst::TryBegin: { + o << getExpressionName(inst->origin); + break; + } + case StackInst::BlockEnd: + case StackInst::IfEnd: + case StackInst::LoopEnd: + case StackInst::TryEnd: { + o << "end (" << inst->type << ')'; + break; + } + case StackInst::IfElse: { + o << "else"; + break; + } + case StackInst::Catch: { + o << "catch"; + break; + } + default: + WASM_UNREACHABLE("unexpeted op"); + } + return o; +} + +std::ostream& +WasmPrinter::printStackIR(StackIR* ir, std::ostream& o, Function* func) { + size_t indent = func ? 2 : 0; + auto doIndent = [&indent, &o]() { + for (size_t j = 0; j < indent; j++) { + o << ' '; + } + }; + for (Index i = 0; i < (*ir).size(); i++) { + auto* inst = (*ir)[i]; + if (!inst) { + continue; + } + switch (inst->op) { + case StackInst::Basic: { + doIndent(); + // Pop is a pseudo instruction and should not be printed in the stack IR + // format to make it valid wat form. + if (inst->origin->is()) { + break; + } + PrintExpressionContents(func, o).visit(inst->origin); + break; + } + case StackInst::BlockBegin: + case StackInst::IfBegin: + case StackInst::LoopBegin: + case StackInst::TryBegin: { + doIndent(); + PrintExpressionContents(func, o).visit(inst->origin); + indent++; + break; + } + case StackInst::BlockEnd: + case StackInst::IfEnd: + case StackInst::LoopEnd: + case StackInst::TryEnd: { + indent--; + doIndent(); + o << "end"; + break; + } + case StackInst::IfElse: { + indent--; + doIndent(); + o << "else"; + indent++; + break; + } + case StackInst::Catch: { + indent--; + doIndent(); + o << "catch"; + indent++; + break; + } + default: + WASM_UNREACHABLE("unexpeted op"); + } + std::cout << '\n'; + } + return o; +} + +} // namespace wasm diff --git a/binaryen/src/passes/PrintCallGraph.cpp b/binaryen/src/passes/PrintCallGraph.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/passes/PrintCallGraph.cpp @@ -0,0 +1,112 @@ +/* + * Copyright 2016 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// Prints the call graph in .dot format. You can use http://www.graphviz.org/ to +// view .dot files. +// + +#include +#include + +#include "ir/module-utils.h" +#include "ir/utils.h" +#include "pass.h" +#include "wasm.h" + +namespace wasm { + +struct PrintCallGraph : public Pass { + bool modifiesBinaryenIR() override { return false; } + + void run(PassRunner* runner, Module* module) override { + std::ostream& o = std::cout; + o << "digraph call {\n" + " rankdir = LR;\n" + " subgraph cluster_key {\n" + " node [shape=box, fontname=courier, fontsize=10];\n" + " edge [fontname=courier, fontsize=10];\n" + " label = \"Key\";\n" + " \"Import\" [style=\"filled\", fillcolor=\"turquoise\"];\n" + " \"Export\" [style=\"filled\", fillcolor=\"gray\"];\n" + " \"Indirect Target\" [style=\"filled, rounded\", " + "fillcolor=\"white\"];\n" + " \"A\" -> \"B\" [style=\"filled, rounded\", label = \"Direct " + "Call\"];\n" + " }\n\n" + " node [shape=box, fontname=courier, fontsize=10];\n"; + + // Defined functions + ModuleUtils::iterDefinedFunctions(*module, [&](Function* curr) { + std::cout << " \"" << curr->name + << "\" [style=\"filled\", fillcolor=\"white\"];\n"; + }); + + // Imported functions + ModuleUtils::iterImportedFunctions(*module, [&](Function* curr) { + o << " \"" << curr->name + << "\" [style=\"filled\", fillcolor=\"turquoise\"];\n"; + }); + + // Exports + for (auto& curr : module->exports) { + if (curr->kind == ExternalKind::Function) { + Function* func = module->getFunction(curr->value); + o << " \"" << func->name + << "\" [style=\"filled\", fillcolor=\"gray\"];\n"; + } + } + + struct CallPrinter : public PostWalker { + Module* module; + Function* currFunction; + std::set visitedTargets; // Used to avoid printing duplicate edges. + std::vector allIndirectTargets; + CallPrinter(Module* module) : module(module) { + // Walk function bodies. + ModuleUtils::iterDefinedFunctions(*module, [&](Function* curr) { + currFunction = curr; + visitedTargets.clear(); + walk(curr->body); + }); + } + void visitCall(Call* curr) { + auto* target = module->getFunction(curr->target); + if (visitedTargets.count(target->name) > 0) { + return; + } + visitedTargets.insert(target->name); + std::cout << " \"" << currFunction->name << "\" -> \"" << target->name + << "\"; // call\n"; + } + }; + CallPrinter printer(module); + + // Indirect Targets + for (auto& segment : module->table.segments) { + for (auto& curr : segment.data) { + auto* func = module->getFunction(curr); + o << " \"" << func->name << "\" [style=\"filled, rounded\"];\n"; + } + } + + o << "}\n"; + } +}; + +Pass* createPrintCallGraphPass() { return new PrintCallGraph(); } + +} // namespace wasm diff --git a/binaryen/src/passes/PrintFeatures.cpp b/binaryen/src/passes/PrintFeatures.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/passes/PrintFeatures.cpp @@ -0,0 +1,37 @@ +/* + * Copyright 2019 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// Print out the feature options corresponding to enabled features +// + +#include "pass.h" +#include "wasm-features.h" +#include "wasm.h" + +namespace wasm { + +struct PrintFeatures : public Pass { + void run(PassRunner* runner, Module* module) override { + module->features.iterFeatures([](FeatureSet::Feature f) { + std::cout << "--enable-" << FeatureSet::toString(f) << std::endl; + }); + } +}; + +Pass* createPrintFeaturesPass() { return new PrintFeatures(); } + +} // namespace wasm diff --git a/binaryen/src/passes/PrintFunctionMap.cpp b/binaryen/src/passes/PrintFunctionMap.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/passes/PrintFunctionMap.cpp @@ -0,0 +1,45 @@ +/* + * Copyright 2019 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// Prints the a map of function indexes to function names. This can be +// useful for interpreting a stack trace from a production environment +// where names did not exist on the client. The map looks like this: +// +// 0:foo +// 1:bar +// 2:baz +// + +#include "pass.h" +#include "wasm.h" + +namespace wasm { + +struct PrintFunctionMap : public Pass { + bool modifiesBinaryenIR() override { return false; } + + void run(PassRunner* runner, Module* module) override { + Index i = 0; + for (auto& func : module->functions) { + std::cout << i++ << ':' << func->name.str << '\n'; + } + } +}; + +Pass* createPrintFunctionMapPass() { return new PrintFunctionMap(); } + +} // namespace wasm diff --git a/binaryen/src/passes/ReReloop.cpp b/binaryen/src/passes/ReReloop.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/passes/ReReloop.cpp @@ -0,0 +1,371 @@ +/* + * Copyright 2017 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// Convert the AST to a CFG, and optimize+convert it back to the AST +// using the relooper. +// +// This pass depends on flatten being run before it. +// + +#include + +#include "cfg/Relooper.h" +#include "ir/flat.h" +#include "ir/utils.h" +#include "pass.h" +#include "wasm-builder.h" +#include "wasm-traversal.h" +#include "wasm.h" + +#ifdef RERELOOP_DEBUG +#include +#endif + +namespace wasm { + +struct ReReloop final : public Pass { + bool isFunctionParallel() override { return true; } + + Pass* create() override { return new ReReloop; } + + std::unique_ptr relooper; + std::unique_ptr builder; + + // block handling + + CFG::Block* currCFGBlock = nullptr; + + CFG::Block* makeCFGBlock() { + return relooper->AddBlock(builder->makeBlock()); + } + + CFG::Block* setCurrCFGBlock(CFG::Block* curr) { + if (currCFGBlock) { + finishBlock(); + } + return currCFGBlock = curr; + } + + CFG::Block* startCFGBlock() { return setCurrCFGBlock(makeCFGBlock()); } + + CFG::Block* getCurrCFGBlock() { return currCFGBlock; } + + Block* getCurrBlock() { return currCFGBlock->Code->cast(); } + + void finishBlock() { getCurrBlock()->finalize(); } + + // break handling + + std::map breakTargets; + + void addBreakTarget(Name name, CFG::Block* target) { + breakTargets[name] = target; + } + + CFG::Block* getBreakTarget(Name name) { return breakTargets[name]; } + + // branch handling + + void + addBranch(CFG::Block* from, CFG::Block* to, Expression* condition = nullptr) { + from->AddBranchTo(to, condition); + } + + void addSwitchBranch(CFG::Block* from, + CFG::Block* to, + const std::set& values) { + std::vector list; + for (auto i : values) { + list.push_back(i); + } + from->AddSwitchBranchTo(to, std::move(list)); + } + + // we work using a stack of control flow tasks + + struct Task { + ReReloop& parent; + Task(ReReloop& parent) : parent(parent) {} + virtual void run() { WASM_UNREACHABLE("unimpl"); } + }; + + typedef std::shared_ptr TaskPtr; + std::vector stack; + + struct TriageTask final : public Task { + Expression* curr; + + TriageTask(ReReloop& parent, Expression* curr) : Task(parent), curr(curr) {} + + void run() override { parent.triage(curr); } + }; + + struct BlockTask final : public Task { + Block* curr; + CFG::Block* later; + + BlockTask(ReReloop& parent, Block* curr) : Task(parent), curr(curr) {} + + static void handle(ReReloop& parent, Block* curr) { + if (curr->name.is()) { + // we may be branched to. create a target, and + // ensure we are called at the join point + auto task = std::make_shared(parent, curr); + task->curr = curr; + task->later = parent.makeCFGBlock(); + parent.addBreakTarget(curr->name, task->later); + parent.stack.push_back(task); + } + auto& list = curr->list; + for (int i = int(list.size()) - 1; i >= 0; i--) { + parent.stack.push_back(std::make_shared(parent, list[i])); + } + } + + void run() override { + // add fallthrough + parent.addBranch(parent.getCurrCFGBlock(), later); + parent.setCurrCFGBlock(later); + } + }; + + struct LoopTask final : public Task { + static void handle(ReReloop& parent, Loop* curr) { + parent.stack.push_back(std::make_shared(parent, curr->body)); + if (curr->name.is()) { + // we may be branched to. create a target + auto* before = parent.getCurrCFGBlock(); + auto* top = parent.startCFGBlock(); + parent.addBreakTarget(curr->name, top); + parent.addBranch(before, top); + } + } + }; + + struct IfTask final : public Task { + If* curr; + CFG::Block* condition; + CFG::Block* ifTrueEnd; + int phase = 0; + + IfTask(ReReloop& parent, If* curr) : Task(parent), curr(curr) {} + + static void handle(ReReloop& parent, If* curr) { + auto task = std::make_shared(parent, curr); + task->curr = curr; + task->condition = parent.getCurrCFGBlock(); + auto* ifTrueBegin = parent.startCFGBlock(); + parent.addBranch(task->condition, ifTrueBegin, curr->condition); + if (curr->ifFalse) { + parent.stack.push_back(task); + parent.stack.push_back( + std::make_shared(parent, curr->ifFalse)); + } + parent.stack.push_back(task); + parent.stack.push_back( + std::make_shared(parent, curr->ifTrue)); + } + + void run() override { + if (phase == 0) { + // end of ifTrue + ifTrueEnd = parent.getCurrCFGBlock(); + auto* after = parent.startCFGBlock(); + // if condition was false, go after the ifTrue, to ifFalse or outside + parent.addBranch(condition, after); + if (!curr->ifFalse) { + parent.addBranch(ifTrueEnd, after); + } + phase++; + } else if (phase == 1) { + // end if ifFalse + auto* ifFalseEnd = parent.getCurrCFGBlock(); + auto* after = parent.startCFGBlock(); + parent.addBranch(ifTrueEnd, after); + parent.addBranch(ifFalseEnd, after); + } else { + WASM_UNREACHABLE("invalid phase"); + } + } + }; + + struct BreakTask : public Task { + static void handle(ReReloop& parent, Break* curr) { + // add the branch. note how if the condition is false, it is the right + // value there as well + auto* before = parent.getCurrCFGBlock(); + parent.addBranch( + before, parent.getBreakTarget(curr->name), curr->condition); + if (curr->condition) { + auto* after = parent.startCFGBlock(); + parent.addBranch(before, after); + } else { + parent.stopControlFlow(); + } + } + }; + + struct SwitchTask : public Task { + static void handle(ReReloop& parent, Switch* curr) { + // set the switch condition for the block ending now + auto* before = parent.getCurrCFGBlock(); + assert(!before->SwitchCondition); + before->SwitchCondition = curr->condition; + std::map> targetValues; + auto& targets = curr->targets; + auto num = targets.size(); + for (Index i = 0; i < num; i++) { + targetValues[targets[i]].insert(i); + } + for (auto& iter : targetValues) { + parent.addSwitchBranch( + before, parent.getBreakTarget(iter.first), iter.second); + } + // the default may be among the targets, in which case, we can't add it + // simply as it would be a duplicate, so create a temp block + if (targetValues.count(curr->default_) == 0) { + parent.addSwitchBranch( + before, parent.getBreakTarget(curr->default_), std::set()); + } else { + auto* temp = parent.startCFGBlock(); + parent.addSwitchBranch(before, temp, std::set()); + parent.addBranch(temp, parent.getBreakTarget(curr->default_)); + } + parent.stopControlFlow(); + } + }; + + struct ReturnTask : public Task { + static void handle(ReReloop& parent, Return* curr) { + // reuse the return + parent.getCurrBlock()->list.push_back(curr); + parent.stopControlFlow(); + } + }; + + struct UnreachableTask : public Task { + static void handle(ReReloop& parent, Unreachable* curr) { + // reuse the unreachable + parent.getCurrBlock()->list.push_back(curr); + parent.stopControlFlow(); + } + }; + + // handle an element we encounter + + void triage(Expression* curr) { + if (auto* block = curr->dynCast()) { + BlockTask::handle(*this, block); + } else if (auto* loop = curr->dynCast()) { + LoopTask::handle(*this, loop); + } else if (auto* iff = curr->dynCast()) { + IfTask::handle(*this, iff); + } else if (auto* br = curr->dynCast()) { + BreakTask::handle(*this, br); + } else if (auto* sw = curr->dynCast()) { + SwitchTask::handle(*this, sw); + } else if (auto* ret = curr->dynCast()) { + ReturnTask::handle(*this, ret); + } else if (auto* un = curr->dynCast()) { + UnreachableTask::handle(*this, un); + } else if (curr->is() || curr->is() || curr->is() || + curr->is()) { + Fatal() << "ReReloop does not support EH instructions yet"; + } else { + // not control flow, so just a simple element + getCurrBlock()->list.push_back(curr); + } + } + + void stopControlFlow() { + startCFGBlock(); + // TODO: optimize with this? + } + + void runOnFunction(PassRunner* runner, + Module* module, + Function* function) override { + Flat::verifyFlatness(function); + + // since control flow is flattened, this is pretty simple + // first, traverse the function body. note how we don't need to traverse + // into expressions, as we know they contain no control flow + builder = make_unique(*module); + relooper = make_unique(module); + auto* entry = startCFGBlock(); + stack.push_back(TaskPtr(new TriageTask(*this, function->body))); + // main loop + while (stack.size() > 0) { + TaskPtr curr = stack.back(); + stack.pop_back(); + curr->run(); + } + // finish the current block + finishBlock(); + // blocks that do not have any exits are dead ends in the relooper. we need + // to make sure that are in fact dead ends, and do not flow control + // anywhere. add a return as needed + for (auto& cfgBlock : relooper->Blocks) { + auto* block = cfgBlock->Code->cast(); + if (cfgBlock->BranchesOut.empty() && block->type != Type::unreachable) { + block->list.push_back(function->sig.results == Type::none + ? (Expression*)builder->makeReturn() + : (Expression*)builder->makeUnreachable()); + block->finalize(); + } + } +#ifdef RERELOOP_DEBUG + std::cout << "rerelooping " << function->name << '\n'; + for (auto* block : relooper->Blocks) { + std::cout << block << " block:\n" << block->Code << '\n'; + for (auto& pair : block->BranchesOut) { + auto* target = pair.first; + auto* branch = pair.second; + std::cout << "branch to " << target << "\n"; + if (branch->Condition) { + std::cout << " with condition\n" << branch->Condition << '\n'; + } + } + } +#endif + // run the relooper to recreate control flow + relooper->Calculate(entry); + // render + { + auto temp = builder->addVar(function, Type::i32); + CFG::RelooperBuilder builder(*module, temp); + function->body = relooper->Render(builder); + // if the function has a result, and the relooper emitted + // something that seems like it flows out without a value + // (but that path is never reached; it just has a br to it + // because of the relooper's boilerplate switch-handling + // code, for example, which could be optimized out later + // but isn't yet), then make sure it has a proper type + if (function->sig.results != Type::none && + function->body->type == Type::none) { + function->body = + builder.makeSequence(function->body, builder.makeUnreachable()); + } + } + // TODO: should this be in the relooper itself? + ReFinalize().walk(function->body); + } +}; + +Pass* createReReloopPass() { return new ReReloop(); } + +} // namespace wasm diff --git a/binaryen/src/passes/RedundantSetElimination.cpp b/binaryen/src/passes/RedundantSetElimination.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/passes/RedundantSetElimination.cpp @@ -0,0 +1,398 @@ +/* + * Copyright 2017 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// Eliminate redundant local.sets: if a local already has a particular +// value, we don't need to set it again. A common case here is loops +// that start at zero, since the default value is initialized to +// zero anyhow. +// +// A risk here is that we extend live ranges, e.g. we may use the default +// value at the very end of a function, keeping that local alive throughout. +// For that reason it is probably better to run this near the end of +// optimization, and especially after coalesce-locals. A final vaccum +// should be done after it, as this pass can leave around drop()s of +// values no longer necessary. +// +// So far this tracks constant values, and for everything else it considers +// them unique (so each local.set of a non-constant is a unique value, each +// merge is a unique value, etc.; there is no sophisticated value numbering +// here). +// + +#include +#include +#include +#include +#include +#include +#include +#include + +namespace wasm { + +// We do a very simple numbering of local values, just a unique +// number for constants so far, enough to see +// trivial duplication. LocalValues maps each local index to +// its current value +typedef std::vector LocalValues; + +namespace { + +// information in a basic block +struct Info { + LocalValues start, end; // the local values at the start and end of the block + std::vector setps; +}; + +struct RedundantSetElimination + : public WalkerPass, + Info>> { + bool isFunctionParallel() override { return true; } + + Pass* create() override { return new RedundantSetElimination(); } + + Index numLocals; + + // cfg traversal work + + static void doVisitLocalSet(RedundantSetElimination* self, + Expression** currp) { + if (self->currBasicBlock) { + self->currBasicBlock->contents.setps.push_back(currp); + } + } + + // main entry point + + void doWalkFunction(Function* func) { + numLocals = func->getNumLocals(); + if (numLocals == 0) { + return; // nothing to do + } + // create the CFG by walking the IR + CFGWalker, Info>:: + doWalkFunction(func); + // flow values across blocks + flowValues(func); + // remove redundant sets + optimize(); + } + + // numbering + + Index nextValue = 1; // 0 is reserved for the "unseen value" + // each constant has a value + std::unordered_map literalValues; + // each value can have a value + std::unordered_map expressionValues; + // each block has values for each merge + std::unordered_map> + blockMergeValues; + + Index getUnseenValue() { // we haven't seen this location yet + return 0; + } + Index getUniqueValue() { +#ifdef RSE_DEBUG + std::cout << "new unique value " << nextValue << '\n'; +#endif + return nextValue++; + } + + Index getLiteralValue(Literals lit) { + auto iter = literalValues.find(lit); + if (iter != literalValues.end()) { + return iter->second; + } +#ifdef RSE_DEBUG + std::cout << "new literal value for " << lit << '\n'; +#endif + return literalValues[lit] = getUniqueValue(); + } + + Index getExpressionValue(Expression* expr) { + auto iter = expressionValues.find(expr); + if (iter != expressionValues.end()) { + return iter->second; + } +#ifdef RSE_DEBUG + std::cout << "new expr value for " << expr << '\n'; +#endif + return expressionValues[expr] = getUniqueValue(); + } + + Index getBlockMergeValue(BasicBlock* block, Index index) { + auto& mergeValues = blockMergeValues[block]; + auto iter = mergeValues.find(index); + if (iter != mergeValues.end()) { + return iter->second; + } +#ifdef RSE_DEBUG + std::cout << "new block-merge value for " << block << " : " << index + << '\n'; +#endif + return mergeValues[index] = getUniqueValue(); + } + + bool isBlockMergeValue(BasicBlock* block, Index index, Index value) { + auto iter = blockMergeValues.find(block); + if (iter == blockMergeValues.end()) { + return false; + } + auto& mergeValues = iter->second; + auto iter2 = mergeValues.find(index); + if (iter2 == mergeValues.end()) { + return false; + } + return value == iter2->second; + } + + Index getValue(Expression* value, LocalValues& currValues) { + if (Properties::isConstantExpression(value)) { + // a constant + return getLiteralValue(Properties::getLiterals(value)); + } else if (auto* get = value->dynCast()) { + // a copy of whatever that was + return currValues[get->index]; + } else { + // get the value's own unique value + return getExpressionValue(value); + } + } + + // flowing + + void flowValues(Function* func) { + for (auto& block : basicBlocks) { + LocalValues& start = block->contents.start; + start.resize(numLocals); + if (block.get() == entry) { + // params are complex values we can't optimize; vars are zeros + for (Index i = 0; i < numLocals; i++) { + if (func->isParam(i)) { +#ifdef RSE_DEBUG + std::cout << "new param value for " << i << '\n'; +#endif + start[i] = getUniqueValue(); + } else { + start[i] = + getLiteralValue(Literal::makeZeros(func->getLocalType(i))); + } + } + } else { + // other blocks have all unseen values to begin with + for (Index i = 0; i < numLocals; i++) { + start[i] = getUnseenValue(); + } + } + // the ends all begin unseen + LocalValues& end = block->contents.end; + end.resize(numLocals); + for (Index i = 0; i < numLocals; i++) { + end[i] = getUnseenValue(); + } + } + // keep working while stuff is flowing. we use a unique deferred queue + // which ensures both FIFO and that we don't do needless work - if + // A and B reach C, and both queue C, we only want to do C at the latest + // time, when we have information from all those reaching it. + UniqueDeferredQueue work; + work.push(entry); + while (!work.empty()) { + auto* curr = work.pop(); +#ifdef RSE_DEBUG + std::cout << "flow block " << curr << '\n'; +#endif + // process a block: first, update its start based on those reaching it + if (!curr->in.empty()) { + if (curr->in.size() == 1) { + // just copy the pred, nothing to merge + curr->contents.start = (*curr->in.begin())->contents.end; + } else { + // perform a merge + auto in = curr->in; + for (Index i = 0; i < numLocals; i++) { + auto old = curr->contents.start[i]; + // If we already had a merge value here, keep it. + // TODO This may have some false positives, as we may e.g. have + // a single pred that first gives us x, then later y after + // flow led to a merge, and we may see x and y at the same + // time due to flow from a successor, and then it looks like + // we need a merge but we don't. avoiding that would require + // more memory and is probably not worth it, but might be + // worth investigating + // NB While suboptimal, this simplification provides a simple proof + // of convergence. We prove that, in each fixed block+local, + // the value number at the end is nondecreasing across + // iterations, by induction on the iteration: + // * The first iteration is on the entry block. It increases + // the value number at the end from 0 (unseen) to something + // else (a value number for 0 for locals, a unique value + // for params; all >0). + // * Induction step: assuming the property holds for all past + // iterations, consider the current iteration. Of our + // predecessors, those that we iterated on have the property; + // those that we haven't will have 0 (unseen). + // * If we assign to that local in this block, that will be + // the value in the output, forever, and it is greater + // than the initial value of 0. + // * If we see different values coming in, we create a merge + // value number. Its number is higher than everything + // else since we give it the next available number, so we + // do not decrease in this iteration, and we will output + // the same value in the future too (here is where we use + // the simplification property). + // * Otherwise, we will flow the incoming value through, + // and it did not decrease (by induction), so neither do + // we. + // Finally, given value numbers are nondecreasing, we must + // converge since we only keep working as long as we see new + // values at the end of a block. + // + // Not that we don't trust this proof, but the convergence + // property (value numbers at block ends do not decrease) is + // verified later down. + if (isBlockMergeValue(curr, i, old)) { + continue; + } + auto iter = in.begin(); + auto value = (*iter)->contents.end[i]; + iter++; + while (iter != in.end()) { + auto otherValue = (*iter)->contents.end[i]; + if (value == getUnseenValue()) { + value = otherValue; + } else if (otherValue == getUnseenValue()) { + // nothing to do, other has no information + } else if (value != otherValue) { + // 2 different values, this is a merged value + value = getBlockMergeValue(curr, i); + break; // no more work once we see a merge + } + iter++; + } + curr->contents.start[i] = value; + } + } + } +#ifdef RSE_DEBUG + dump("start", curr->contents.start); +#endif + // flow values through it, then add those we can reach if they need an + // update. + auto currValues = curr->contents.start; // we'll modify this as we go + auto& setps = curr->contents.setps; + for (auto** setp : setps) { + auto* set = (*setp)->cast(); + currValues[set->index] = getValue(set->value, currValues); + } + if (currValues == curr->contents.end) { + // nothing changed, so no more work to do + // note that the first iteration this is always not the case, + // since end contains unseen (and then the comparison ends on + // the first element) + continue; + } + // update the end state and update children +#ifndef NDEBUG + // verify the convergence property mentioned in the NB comment + // above: the value numbers at the end must be nondecreasing + for (Index i = 0; i < numLocals; i++) { + assert(currValues[i] >= curr->contents.end[i]); + } +#endif + curr->contents.end.swap(currValues); +#ifdef RSE_DEBUG + dump("end ", curr->contents.end); +#endif + for (auto* next : curr->out) { + work.push(next); + } + } + } + + // optimizing + void optimize() { + // in each block, run the values through the sets, + // and remove redundant sets when we see them + for (auto& block : basicBlocks) { + auto currValues = block->contents.start; // we'll modify this as we go + auto& setps = block->contents.setps; + for (auto** setp : setps) { + auto* set = (*setp)->cast(); + auto oldValue = currValues[set->index]; + auto newValue = getValue(set->value, currValues); + auto index = set->index; + if (newValue == oldValue) { + remove(setp); + continue; // no more work to do + } + // update for later steps + currValues[index] = newValue; + } + } + } + + void remove(Expression** setp) { + auto* set = (*setp)->cast(); + auto* value = set->value; + if (!set->isTee()) { + auto* drop = ExpressionManipulator::convert(set); + drop->value = value; + drop->finalize(); + } else { + *setp = value; + } + } + + // debugging + + void dump(BasicBlock* block) { + std::cout << "====\n"; + if (block) { + std::cout << "block: " << block << '\n'; + for (auto* out : block->out) { + std::cout << " goes to " << out << '\n'; + } + } + for (Index i = 0; i < block->contents.start.size(); i++) { + std::cout << " start[" << i << "] = " << block->contents.start[i] + << '\n'; + } + for (auto** setp : block->contents.setps) { + std::cout << " " << *setp << '\n'; + } + std::cout << "====\n"; + } + + void dump(const char* desc, LocalValues& values) { + std::cout << desc << ": "; + for (auto x : values) { + std::cout << x << ' '; + } + std::cout << '\n'; + } +}; + +} // namespace + +Pass* createRedundantSetEliminationPass() { + return new RedundantSetElimination(); +} + +} // namespace wasm diff --git a/binaryen/src/passes/RemoveImports.cpp b/binaryen/src/passes/RemoveImports.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/passes/RemoveImports.cpp @@ -0,0 +1,69 @@ +/* + * Copyright 2015 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// Removes function imports, and replaces them with nops. This is useful +// for running a module through the reference interpreter, which +// does not validate imports for a JS environment (by removing +// imports, we can at least get the reference interpreter to +// look at all the rest of the code). +// + +#include "ir/module-utils.h" +#include "pass.h" +#include "wasm.h" + +namespace wasm { + +struct RemoveImports : public WalkerPass> { + void visitCall(Call* curr) { + auto* func = getModule()->getFunction(curr->target); + if (!func->imported()) { + return; + } + Type type = func->sig.results; + if (type == Type::none) { + replaceCurrent(getModule()->allocator.alloc()); + } else { + Literal nopLiteral(type); + replaceCurrent(getModule()->allocator.alloc()->set(nopLiteral)); + } + } + + void visitModule(Module* curr) { + std::vector names; + ModuleUtils::iterImportedFunctions( + *curr, [&](Function* func) { names.push_back(func->name); }); + // Do not remove names referenced in a table + std::set indirectNames; + if (curr->table.exists) { + for (auto& segment : curr->table.segments) { + for (auto& name : segment.data) { + indirectNames.insert(name); + } + } + } + for (auto& name : names) { + if (indirectNames.find(name) == indirectNames.end()) { + curr->removeFunction(name); + } + } + } +}; + +Pass* createRemoveImportsPass() { return new RemoveImports(); } + +} // namespace wasm diff --git a/binaryen/src/passes/RemoveMemory.cpp b/binaryen/src/passes/RemoveMemory.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/passes/RemoveMemory.cpp @@ -0,0 +1,34 @@ +/* + * Copyright 2016 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// Removeds memory segments, leaving only code in the module. +// + +#include +#include + +namespace wasm { + +struct RemoveMemory : public Pass { + void run(PassRunner* runner, Module* module) override { + module->memory.segments.clear(); + } +}; + +Pass* createRemoveMemoryPass() { return new RemoveMemory(); } + +} // namespace wasm diff --git a/binaryen/src/passes/RemoveNonJSOps.cpp b/binaryen/src/passes/RemoveNonJSOps.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/passes/RemoveNonJSOps.cpp @@ -0,0 +1,392 @@ +/* + * Copyright 2018 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// RemoveNonJSOps removes operations that aren't inherently implementable +// in JS. This includes things like 64-bit division, `f32.nearest`, +// `f64.copysign`, etc. Most operations are lowered to a call to an injected +// intrinsic implementation. Intrinsics don't use themselves to implement +// themselves. +// +// You'll find a large wat blob in `wasm-intrinsics.wat` next to this file +// which contains all of the injected intrinsics. We manually copy over any +// needed intrinsics from this module into the module that we're optimizing +// after walking the current module. +// +// StubUnsupportedJSOps stubs out operations that are not fully supported +// even with RemoveNonJSOps. For example, i64->f32 conversions do not have +// perfect rounding in all cases. StubUnsupportedJSOps removes those entirely +// and replaces them with "stub" operations that do nothing. This is only +// really useful for fuzzing as it changes the behavior of the program. +// + +#include +#include + +#include "abi/js.h" +#include "asmjs/shared-constants.h" +#include "ir/find_all.h" +#include "ir/literal-utils.h" +#include "ir/memory-utils.h" +#include "ir/module-utils.h" +#include "passes/intrinsics-module.h" +#include "wasm-builder.h" +#include "wasm-s-parser.h" + +namespace wasm { + +struct RemoveNonJSOpsPass : public WalkerPass> { + std::unique_ptr builder; + std::unordered_set neededIntrinsics; + std::set> neededImportedGlobals; + + bool isFunctionParallel() override { return false; } + + Pass* create() override { return new RemoveNonJSOpsPass; } + + void doWalkModule(Module* module) { + // Intrinsics may use scratch memory, ensure it. + ABI::wasm2js::ensureHelpers(module); + + // Discover all of the intrinsics that we need to inject, lowering all + // operations to intrinsic calls while we're at it. + if (!builder) { + builder = make_unique(*module); + } + PostWalker::doWalkModule(module); + + if (neededIntrinsics.size() == 0) { + return; + } + + // Parse the wat blob we have at the end of this file. + // + // TODO: only do this once per invocation of wasm2asm + Module intrinsicsModule; + std::string input(IntrinsicsModuleWast); + SExpressionParser parser(const_cast(input.c_str())); + Element& root = *parser.root; + SExpressionWasmBuilder builder( + intrinsicsModule, *root[0], IRProfile::Normal); + + std::set neededFunctions; + + // Iteratively link intrinsics from `intrinsicsModule` into our destination + // module, as needed. + // + // Note that intrinsics often use one another. For example the 64-bit + // division intrinsic ends up using the 32-bit ctz intrinsic, but does so + // via a native instruction. The loop here is used to continuously reprocess + // injected intrinsics to ensure that they never contain non-js ops when + // we're done. + while (neededIntrinsics.size() > 0) { + // Recursively probe all needed intrinsics for transitively used + // functions. This is building up a set of functions we'll link into our + // module. + for (auto& name : neededIntrinsics) { + addNeededFunctions(intrinsicsModule, name, neededFunctions); + } + neededIntrinsics.clear(); + + // Link in everything that wasn't already linked in. After we've done the + // copy we then walk the function to rewrite any non-js operations it has + // as well. + for (auto& name : neededFunctions) { + auto* func = module->getFunctionOrNull(name); + if (!func) { + func = ModuleUtils::copyFunction(intrinsicsModule.getFunction(name), + *module); + } + doWalkFunction(func); + } + neededFunctions.clear(); + } + + // Copy all the globals in the intrinsics module + for (auto& global : intrinsicsModule.globals) { + ModuleUtils::copyGlobal(global.get(), *module); + } + + // Intrinsics may use memory, so ensure the module has one. + MemoryUtils::ensureExists(module->memory); + + // Add missing globals + for (auto& pair : neededImportedGlobals) { + auto name = pair.first; + auto type = pair.second; + if (!getModule()->getGlobalOrNull(name)) { + auto global = make_unique(); + global->name = name; + global->type = type; + global->mutable_ = false; + global->module = ENV; + global->base = name; + module->addGlobal(global.release()); + } + } + } + + void addNeededFunctions(Module& m, Name name, std::set& needed) { + if (needed.count(name)) { + return; + } + needed.insert(name); + + auto function = m.getFunction(name); + FindAll calls(function->body); + for (auto* call : calls.list) { + auto* called = m.getFunction(call->target); + if (!called->imported()) { + this->addNeededFunctions(m, call->target, needed); + } + } + } + + void doWalkFunction(Function* func) { + if (!builder) { + builder = make_unique(*getModule()); + } + PostWalker::doWalkFunction(func); + } + + void visitLoad(Load* curr) { + if (curr->align == 0 || curr->align >= curr->bytes) { + return; + } + + // Switch unaligned loads of floats to unaligned loads of integers (which we + // can actually implement) and then use reinterpretation to get the float + // back out. + switch (curr->type.getBasic()) { + case Type::f32: + curr->type = Type::i32; + replaceCurrent(builder->makeUnary(ReinterpretInt32, curr)); + break; + case Type::f64: + curr->type = Type::i64; + replaceCurrent(builder->makeUnary(ReinterpretInt64, curr)); + break; + default: + break; + } + } + + void visitStore(Store* curr) { + if (curr->align == 0 || curr->align >= curr->bytes) { + return; + } + + // Switch unaligned stores of floats to unaligned stores of integers (which + // we can actually implement) and then use reinterpretation to store the + // right value. + switch (curr->valueType.getBasic()) { + case Type::f32: + curr->valueType = Type::i32; + curr->value = builder->makeUnary(ReinterpretFloat32, curr->value); + break; + case Type::f64: + curr->valueType = Type::i64; + curr->value = builder->makeUnary(ReinterpretFloat64, curr->value); + break; + default: + break; + } + } + + void visitBinary(Binary* curr) { + Name name; + switch (curr->op) { + case CopySignFloat32: + case CopySignFloat64: + rewriteCopysign(curr); + return; + + case RotLInt32: + name = WASM_ROTL32; + break; + case RotRInt32: + name = WASM_ROTR32; + break; + case RotLInt64: + name = WASM_ROTL64; + break; + case RotRInt64: + name = WASM_ROTR64; + break; + case MulInt64: + name = WASM_I64_MUL; + break; + case DivSInt64: + name = WASM_I64_SDIV; + break; + case DivUInt64: + name = WASM_I64_UDIV; + break; + case RemSInt64: + name = WASM_I64_SREM; + break; + case RemUInt64: + name = WASM_I64_UREM; + break; + + default: + return; + } + neededIntrinsics.insert(name); + replaceCurrent( + builder->makeCall(name, {curr->left, curr->right}, curr->type)); + } + + void rewriteCopysign(Binary* curr) { + Literal signBit, otherBits; + UnaryOp int2float, float2int; + BinaryOp bitAnd, bitOr; + switch (curr->op) { + case CopySignFloat32: + float2int = ReinterpretFloat32; + int2float = ReinterpretInt32; + bitAnd = AndInt32; + bitOr = OrInt32; + signBit = Literal(uint32_t(1 << 31)); + otherBits = Literal(uint32_t(1 << 31) - 1); + break; + + case CopySignFloat64: + float2int = ReinterpretFloat64; + int2float = ReinterpretInt64; + bitAnd = AndInt64; + bitOr = OrInt64; + signBit = Literal(uint64_t(1) << 63); + otherBits = Literal((uint64_t(1) << 63) - 1); + break; + + default: + return; + } + + replaceCurrent(builder->makeUnary( + int2float, + builder->makeBinary( + bitOr, + builder->makeBinary(bitAnd, + builder->makeUnary(float2int, curr->left), + builder->makeConst(otherBits)), + builder->makeBinary(bitAnd, + builder->makeUnary(float2int, curr->right), + builder->makeConst(signBit))))); + } + + void visitUnary(Unary* curr) { + Name functionCall; + switch (curr->op) { + case NearestFloat32: + functionCall = WASM_NEAREST_F32; + break; + case NearestFloat64: + functionCall = WASM_NEAREST_F64; + break; + + case TruncFloat32: + functionCall = WASM_TRUNC_F32; + break; + case TruncFloat64: + functionCall = WASM_TRUNC_F64; + break; + + case PopcntInt64: + functionCall = WASM_POPCNT64; + break; + case PopcntInt32: + functionCall = WASM_POPCNT32; + break; + + case CtzInt64: + functionCall = WASM_CTZ64; + break; + case CtzInt32: + functionCall = WASM_CTZ32; + break; + + default: + return; + } + neededIntrinsics.insert(functionCall); + replaceCurrent(builder->makeCall(functionCall, {curr->value}, curr->type)); + } + + void visitGlobalGet(GlobalGet* curr) { + neededImportedGlobals.insert(std::make_pair(curr->name, curr->type)); + } +}; + +struct StubUnsupportedJSOpsPass + : public WalkerPass> { + bool isFunctionParallel() override { return true; } + + Pass* create() override { return new StubUnsupportedJSOpsPass; } + + void visitUnary(Unary* curr) { + switch (curr->op) { + case ConvertUInt64ToFloat32: + // See detailed comment in lowerConvertIntToFloat in + // I64ToI32Lowering.cpp. + stubOut(curr->value, curr->type); + break; + default: { + } + } + } + + void visitCallIndirect(CallIndirect* curr) { + // Indirect calls of the wrong type trap in wasm, but not in wasm2js. Remove + // the indirect call, but leave the arguments. + Builder builder(*getModule()); + std::vector items; + for (auto* operand : curr->operands) { + items.push_back(builder.makeDrop(operand)); + } + items.push_back(builder.makeDrop(curr->target)); + stubOut(builder.makeBlock(items), curr->type); + } + + void stubOut(Expression* value, Type outputType) { + Builder builder(*getModule()); + // In some cases we can just replace with the value. + auto* replacement = value; + if (outputType == Type::unreachable) { + // This is unreachable anyhow; just leave the value instead of the + // original node. + assert(value->type == Type::unreachable); + } else if (outputType != Type::none) { + // Drop the value if we need to. + if (value->type != Type::none) { + value = builder.makeDrop(value); + } + // Return something with the right output type. + replacement = builder.makeSequence( + value, LiteralUtils::makeZero(outputType, *getModule())); + } + replaceCurrent(replacement); + } +}; + +Pass* createRemoveNonJSOpsPass() { return new RemoveNonJSOpsPass(); } + +Pass* createStubUnsupportedJSOpsPass() { + return new StubUnsupportedJSOpsPass(); +} + +} // namespace wasm diff --git a/binaryen/src/passes/RemoveUnusedBrs.cpp b/binaryen/src/passes/RemoveUnusedBrs.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/passes/RemoveUnusedBrs.cpp @@ -0,0 +1,1299 @@ +/* + * Copyright 2015 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// Removes branches for which we go to where they go anyhow +// + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace wasm { + +// to turn an if into a br-if, we must be able to reorder the +// condition and possible value, and the possible value must +// not have side effects (as they would run unconditionally) +static bool canTurnIfIntoBrIf(Expression* ifCondition, + Expression* brValue, + PassOptions& options, + FeatureSet features) { + // if the if isn't even reached, this is all dead code anyhow + if (ifCondition->type == Type::unreachable) { + return false; + } + if (!brValue) { + return true; + } + EffectAnalyzer value(options, features, brValue); + if (value.hasSideEffects()) { + return false; + } + return !EffectAnalyzer(options, features, ifCondition).invalidates(value); +} + +// Check if it is not worth it to run code unconditionally. This +// assumes we are trying to run two expressions where previously +// only one of the two might have executed. We assume here that +// executing both is good for code size. +static bool tooCostlyToRunUnconditionally(const PassOptions& passOptions, + Expression* one, + Expression* two) { + // If we care mostly about code size, just do it for that reason. + if (passOptions.shrinkLevel) { + return false; + } + // Consider the cost of executing all the code unconditionally. + const auto TOO_MUCH = 7; + auto total = CostAnalyzer(one).cost + CostAnalyzer(two).cost; + return total >= TOO_MUCH; +} + +struct RemoveUnusedBrs : public WalkerPass> { + bool isFunctionParallel() override { return true; } + + Pass* create() override { return new RemoveUnusedBrs; } + + bool anotherCycle; + + typedef std::vector Flows; + + // list of breaks that are currently flowing. if they reach their target + // without interference, they can be removed (or their value forwarded TODO) + Flows flows; + + // a stack for if-else contents, we merge their outputs + std::vector ifStack; + + // list of all loops, so we can optimize them + std::vector loops; + + static void visitAny(RemoveUnusedBrs* self, Expression** currp) { + auto* curr = *currp; + auto& flows = self->flows; + + if (curr->is()) { + flows.clear(); + auto* br = curr->cast(); + if (!br->condition) { // TODO: optimize? + // a break, let's see where it flows to + flows.push_back(currp); + } else { + self->stopValueFlow(); + } + } else if (curr->is()) { + flows.clear(); + flows.push_back(currp); + } else if (curr->is()) { + auto* iff = curr->cast(); + if (iff->condition->type == Type::unreachable) { + // avoid trying to optimize this, we never reach it anyhow + self->stopFlow(); + return; + } + if (iff->ifFalse) { + assert(self->ifStack.size() > 0); + auto ifTrueFlows = std::move(self->ifStack.back()); + self->ifStack.pop_back(); + // we can flow values out in most cases, except if one arm + // has the none type - we will update the types later, but + // there is no way to emit a proper type for one arm being + // none and the other flowing a value; and there is no way + // to flow a value from a none. + if (iff->ifTrue->type == Type::none || + iff->ifFalse->type == Type::none) { + self->removeValueFlow(ifTrueFlows); + self->stopValueFlow(); + } + for (auto* flow : ifTrueFlows) { + flows.push_back(flow); + } + } else { + // if without else stops the flow of values + self->stopValueFlow(); + } + } else if (auto* block = curr->dynCast()) { + // any breaks flowing to here are unnecessary, as we get here anyhow + auto name = block->name; + auto& list = block->list; + if (name.is()) { + Index size = flows.size(); + Index skip = 0; + for (Index i = 0; i < size; i++) { + auto* flow = (*flows[i])->dynCast(); + if (flow && flow->name == name) { + if (!flow->value) { + // br => nop + ExpressionManipulator::nop(flow); + } else { + // br with value => value + *flows[i] = flow->value; + } + skip++; + self->anotherCycle = true; + } else if (skip > 0) { + flows[i - skip] = flows[i]; + } + } + if (skip > 0) { + flows.resize(size - skip); + } + // drop a nop at the end of a block, which prevents a value flowing + while (list.size() > 0 && list.back()->is()) { + list.resize(list.size() - 1); + self->anotherCycle = true; + } + } + // A value flowing is only valid if it is a value that the block actually + // flows out. If it is never reached, it does not flow out, and may be + // invalid to represent as such. + auto size = list.size(); + for (Index i = 0; i < size; i++) { + if (i != size - 1 && list[i]->type == Type::unreachable) { + // No value flows out of this block. + self->stopValueFlow(); + break; + } + } + } else if (curr->is()) { + // ignore (could be result of a previous cycle) + self->stopValueFlow(); + } else if (curr->is()) { + // do nothing - it's ok for values to flow out + } else if (auto* sw = curr->dynCast()) { + self->stopFlow(); + self->optimizeSwitch(sw); + } else { + // anything else stops the flow + self->stopFlow(); + } + } + + void stopFlow() { flows.clear(); } + + void removeValueFlow(Flows& currFlows) { + currFlows.erase(std::remove_if(currFlows.begin(), + currFlows.end(), + [&](Expression** currp) { + auto* curr = *currp; + if (auto* ret = curr->dynCast()) { + return ret->value; + } + return curr->cast()->value; + }), + currFlows.end()); + } + + void stopValueFlow() { removeValueFlow(flows); } + + static void clear(RemoveUnusedBrs* self, Expression** currp) { + self->flows.clear(); + } + + static void saveIfTrue(RemoveUnusedBrs* self, Expression** currp) { + self->ifStack.push_back(std::move(self->flows)); + } + + void visitLoop(Loop* curr) { loops.push_back(curr); } + + void optimizeSwitch(Switch* curr) { + // if the final element is the default, we don't need it + while (!curr->targets.empty() && curr->targets.back() == curr->default_) { + curr->targets.pop_back(); + } + // if the first element is the default, we can remove it by shifting + // everything (which does add a subtraction of a constant, but often that is + // worth it as the constant can be folded away and/or we remove multiple + // elements here) + Index removable = 0; + while (removable < curr->targets.size() && + curr->targets[removable] == curr->default_) { + removable++; + } + if (removable > 0) { + for (Index i = removable; i < curr->targets.size(); i++) { + curr->targets[i - removable] = curr->targets[i]; + } + curr->targets.resize(curr->targets.size() - removable); + Builder builder(*getModule()); + curr->condition = builder.makeBinary( + SubInt32, curr->condition, builder.makeConst(int32_t(removable))); + } + // when there isn't a value, we can do some trivial optimizations without + // worrying about the value being executed before the condition + if (curr->value) { + return; + } + if (curr->targets.size() == 0) { + // a switch with just a default always goes there + Builder builder(*getModule()); + replaceCurrent(builder.makeSequence(builder.makeDrop(curr->condition), + builder.makeBreak(curr->default_))); + } else if (curr->targets.size() == 1) { + // a switch with two options is basically an if + Builder builder(*getModule()); + replaceCurrent(builder.makeIf(curr->condition, + builder.makeBreak(curr->default_), + builder.makeBreak(curr->targets.front()))); + } else { + // there are also some other cases where we want to convert a switch into + // ifs, especially if the switch is large and we are focusing on size. an + // especially egregious case is a switch like this: [a b b [..] b b c] + // with default b (which may be arrived at after we trim away excess + // default values on both sides). in this case, we really have 3 values in + // a simple form, so it is the next logical case after handling 1 and 2 + // values right above here. to optimize this, we must add a local + a + // bunch of nodes (if*2, tee, eq, get, const, break*3), so the table must + // be big enough for it to make sense + + // How many targets we need when shrinking. This is literally the size at + // which the transformation begins to be smaller. + const uint32_t MIN_SHRINK = 13; + // How many targets we need when not shrinking, in which case, 2 ifs may + // be slower, so we do this when the table is ridiculously large for one + // with just 3 values in it. + const uint32_t MIN_GENERAL = 128; + + auto shrink = getPassRunner()->options.shrinkLevel > 0; + if ((curr->targets.size() >= MIN_SHRINK && shrink) || + (curr->targets.size() >= MIN_GENERAL && !shrink)) { + for (Index i = 1; i < curr->targets.size() - 1; i++) { + if (curr->targets[i] != curr->default_) { + return; + } + } + // great, we are in that case, optimize + Builder builder(*getModule()); + auto temp = builder.addVar(getFunction(), Type::i32); + Expression* z; + replaceCurrent(z = builder.makeIf( + builder.makeLocalTee(temp, curr->condition, Type::i32), + builder.makeIf(builder.makeBinary( + EqInt32, + builder.makeLocalGet(temp, Type::i32), + builder.makeConst( + int32_t(curr->targets.size() - 1))), + builder.makeBreak(curr->targets.back()), + builder.makeBreak(curr->default_)), + builder.makeBreak(curr->targets.front()))); + } + } + } + + void visitIf(If* curr) { + FeatureSet features = getModule()->features; + if (!curr->ifFalse) { + // if without an else. try to reduce + // if (condition) br => br_if (condition) + if (Break* br = curr->ifTrue->dynCast()) { + if (canTurnIfIntoBrIf( + curr->condition, br->value, getPassOptions(), features)) { + if (!br->condition) { + br->condition = curr->condition; + } else { + // In this case we can replace + // if (condition1) br_if (condition2) + // => + // br_if select (condition1) (condition2) (i32.const 0) + // In other words, we replace an if (3 bytes) with a select and a + // zero (also 3 bytes). The size is unchanged, but the select may + // be further optimizable, and if select does not branch we also + // avoid one branch. + // Multivalue selects are not supported + if (br->value && br->value->type.isTuple()) { + return; + } + // If running the br's condition unconditionally is too expensive, + // give up. + auto* zero = LiteralUtils::makeZero(Type::i32, *getModule()); + if (tooCostlyToRunUnconditionally( + getPassOptions(), br->condition, zero)) { + return; + } + // Of course we can't do this if the br's condition has side + // effects, as we would then execute those unconditionally. + if (EffectAnalyzer(getPassOptions(), features, br->condition) + .hasSideEffects()) { + return; + } + Builder builder(*getModule()); + // Note that we use the br's condition as the select condition. + // That keeps the order of the two conditions as it was originally. + br->condition = + builder.makeSelect(br->condition, curr->condition, zero); + } + br->finalize(); + replaceCurrent(Builder(*getModule()).dropIfConcretelyTyped(br)); + anotherCycle = true; + } + } + } + // TODO: if-else can be turned into a br_if as well, if one of the sides is + // a dead end we handle the case of a returned value to a local.set + // later down, see visitLocalSet. + } + + // override scan to add a pre and a post check task to all nodes + static void scan(RemoveUnusedBrs* self, Expression** currp) { + self->pushTask(visitAny, currp); + + auto* iff = (*currp)->dynCast(); + + if (iff) { + if (iff->condition->type == Type::unreachable) { + // avoid trying to optimize this, we never reach it anyhow + return; + } + self->pushTask(doVisitIf, currp); + if (iff->ifFalse) { + // we need to join up if-else control flow, and clear after the + // condition + self->pushTask(scan, &iff->ifFalse); + // safe the ifTrue flow, we'll join it later + self->pushTask(saveIfTrue, currp); + } + self->pushTask(scan, &iff->ifTrue); + self->pushTask(clear, currp); // clear all flow after the condition + self->pushTask(scan, &iff->condition); + } else { + super::scan(self, currp); + } + } + + // optimizes a loop. returns true if we made changes + bool optimizeLoop(Loop* loop) { + // if a loop ends in + // (loop $in + // (block $out + // if (..) br $in; else br $out; + // ) + // ) + // then our normal opts can remove the break out since it flows directly out + // (and later passes make the if one-armed). however, the simple analysis + // fails on patterns like + // if (..) br $out; + // br $in; + // which is a common way to do a while (1) loop (end it with a jump to the + // top), so we handle that here. Specifically we want to conditionalize + // breaks to the loop top, i.e., put them behind a condition, so that other + // code can flow directly out and thus brs out can be removed. (even if + // the change is to let a break somewhere else flow out, that can still be + // helpful, as it shortens the logical loop. it is also good to generate + // an if-else instead of an if, as it might allow an eqz to be removed + // by flipping arms) + if (!loop->name.is()) { + return false; + } + auto* block = loop->body->dynCast(); + if (!block) { + return false; + } + // does the last element break to the top of the loop? + auto& list = block->list; + if (list.size() <= 1) { + return false; + } + auto* last = list.back()->dynCast(); + if (!last || !ExpressionAnalyzer::isSimple(last) || + last->name != loop->name) { + return false; + } + // last is a simple break to the top of the loop. if we can conditionalize + // it, it won't block things from flowing out and not needing breaks to do + // so. + Index i = list.size() - 2; + Builder builder(*getModule()); + while (1) { + auto* curr = list[i]; + if (auto* iff = curr->dynCast()) { + // let's try to move the code going to the top of the loop into the + // if-else + if (!iff->ifFalse) { + // we need the ifTrue to break, so it cannot reach the code we want to + // move + if (iff->ifTrue->type == Type::unreachable) { + iff->ifFalse = builder.stealSlice(block, i + 1, list.size()); + iff->finalize(); + block->finalize(); + return true; + } + } else { + // this is already an if-else. if one side is a dead end, we can + // append to the other, if there is no returned value to concern us + + // can't be, since in the middle of a block + assert(!iff->type.isConcrete()); + + // ensures the first node is a block, if it isn't already, and merges + // in the second, either as a single element or, if a block, by + // appending to the first block. this keeps the order of operations in + // place, that is, the appended element will be executed after the + // first node's elements + auto blockifyMerge = [&](Expression* any, + Expression* append) -> Block* { + Block* block = nullptr; + if (any) { + block = any->dynCast(); + } + // if the first isn't a block, or it's a block with a name (so we + // might branch to the end, and so can't append to it, we might skip + // that code!) then make a new block + if (!block || block->name.is()) { + block = builder.makeBlock(any); + } else { + assert(!block->type.isConcrete()); + } + auto* other = append->dynCast(); + if (!other) { + block->list.push_back(append); + } else { + for (auto* item : other->list) { + block->list.push_back(item); + } + } + block->finalize(); + return block; + }; + + if (iff->ifTrue->type == Type::unreachable) { + iff->ifFalse = blockifyMerge( + iff->ifFalse, builder.stealSlice(block, i + 1, list.size())); + iff->finalize(); + block->finalize(); + return true; + } else if (iff->ifFalse->type == Type::unreachable) { + iff->ifTrue = blockifyMerge( + iff->ifTrue, builder.stealSlice(block, i + 1, list.size())); + iff->finalize(); + block->finalize(); + return true; + } + } + return false; + } else if (auto* brIf = curr->dynCast()) { + // br_if is similar to if. + if (brIf->condition && !brIf->value && brIf->name != loop->name) { + if (i == list.size() - 2) { + // there is the br_if, and then the br to the top, so just flip them + // and the condition + brIf->condition = builder.makeUnary(EqZInt32, brIf->condition); + last->name = brIf->name; + brIf->name = loop->name; + return true; + } else { + // there are elements in the middle, + // br_if $somewhere (condition) + // (..more..) + // br $in + // we can convert the br_if to an if. this has a cost, though, + // so only do it if it looks useful, which it definitely is if + // (a) $somewhere is straight out (so the br out vanishes), and + // (b) this br_if is the only branch to that block (so the block + // will vanish) + if (brIf->name == block->name && + BranchUtils::BranchSeeker::count(block, block->name) == 1) { + // note that we could drop the last element here, it is a br we + // know for sure is removable, but telling stealSlice to steal all + // to the end is more efficient, it can just truncate. + list[i] = + builder.makeIf(brIf->condition, + builder.makeBreak(brIf->name), + builder.stealSlice(block, i + 1, list.size())); + return true; + } + } + } + return false; + } + // if there is control flow, we must stop looking + if (EffectAnalyzer(getPassOptions(), getModule()->features, curr) + .transfersControlFlow()) { + return false; + } + if (i == 0) { + return false; + } + i--; + } + } + + bool sinkBlocks(Function* func) { + struct Sinker : public PostWalker { + bool worked = false; + + void visitBlock(Block* curr) { + // If the block has a single child which is a loop, and the block is + // named, then it is the exit for the loop. It's better to move it into + // the loop, where it can be better optimized by other passes. Similar + // logic for ifs: if the block is an exit for the if, we can move the + // block in, consider for example: + // (block $label + // (if (..condition1..) + // (block + // (br_if $label (..condition2..)) + // (..code..) + // ) + // ) + // ) + // After also merging the blocks, we have + // (if (..condition1..) + // (block $label + // (br_if $label (..condition2..)) + // (..code..) + // ) + // ) + // which can be further optimized later. + if (curr->name.is() && curr->list.size() == 1) { + if (auto* loop = curr->list[0]->dynCast()) { + curr->list[0] = loop->body; + loop->body = curr; + curr->finalize(curr->type); + loop->finalize(); + replaceCurrent(loop); + worked = true; + } else if (auto* iff = curr->list[0]->dynCast()) { + // The label can't be used in the condition. + if (BranchUtils::BranchSeeker::count(iff->condition, curr->name) == + 0) { + // We can move the block into either arm, if there are no uses in + // the other. + Expression** target = nullptr; + if (!iff->ifFalse || BranchUtils::BranchSeeker::count( + iff->ifFalse, curr->name) == 0) { + target = &iff->ifTrue; + } else if (BranchUtils::BranchSeeker::count(iff->ifTrue, + curr->name) == 0) { + target = &iff->ifFalse; + } + if (target) { + curr->list[0] = *target; + *target = curr; + // The block used to contain the if, and may have changed type + // from unreachable to none, for example, if the if has an + // unreachable condition but the arm is not unreachable. + curr->finalize(); + iff->finalize(); + replaceCurrent(iff); + worked = true; + // Note that the type might change, e.g. if the if condition is + // unreachable but the block that was on the outside had a + // break. + } + } + } + } + } + } sinker; + + sinker.doWalkFunction(func); + if (sinker.worked) { + ReFinalize().walkFunctionInModule(func, getModule()); + return true; + } + return false; + } + + void doWalkFunction(Function* func) { + // multiple cycles may be needed + do { + anotherCycle = false; + super::doWalkFunction(func); + assert(ifStack.empty()); + // flows may contain returns, which are flowing out and so can be + // optimized + for (Index i = 0; i < flows.size(); i++) { + auto* flow = (*flows[i])->dynCast(); + if (!flow) { + continue; + } + if (!flow->value) { + // return => nop + ExpressionManipulator::nop(flow); + anotherCycle = true; + } else { + // return with value => value + *flows[i] = flow->value; + anotherCycle = true; + } + } + flows.clear(); + // optimize loops (we don't do it while tracking flows, as they can + // interfere) + for (auto* loop : loops) { + anotherCycle |= optimizeLoop(loop); + } + loops.clear(); + if (anotherCycle) { + ReFinalize().walkFunctionInModule(func, getModule()); + } + // sink blocks + if (sinkBlocks(func)) { + anotherCycle = true; + } + } while (anotherCycle); + + // thread trivial jumps + struct JumpThreader : public ControlFlowWalker { + // map of all value-less breaks and switches going to a block (and not a + // loop) + std::map> branchesToBlock; + + bool worked = false; + + void visitBreak(Break* curr) { + if (!curr->value) { + if (auto* target = findBreakTarget(curr->name)->dynCast()) { + branchesToBlock[target].push_back(curr); + } + } + } + void visitSwitch(Switch* curr) { + if (!curr->value) { + auto names = BranchUtils::getUniqueTargets(curr); + for (auto name : names) { + if (auto* target = findBreakTarget(name)->dynCast()) { + branchesToBlock[target].push_back(curr); + } + } + } + } + void visitBlock(Block* curr) { + auto& list = curr->list; + if (list.size() == 1 && curr->name.is()) { + // if this block has just one child, a sub-block, then jumps to the + // former are jumps to us, really + if (auto* child = list[0]->dynCast()) { + // the two blocks must have the same type for us to update the + // branch, as otherwise one block may be unreachable and the other + // concrete, so one might lack a value + if (child->name.is() && child->name != curr->name && + child->type == curr->type) { + redirectBranches(child, curr->name); + } + } + } else if (list.size() == 2) { + // if this block has two children, a child-block and a simple jump, + // then jumps to child-block can be replaced with jumps to the new + // target + auto* child = list[0]->dynCast(); + auto* jump = list[1]->dynCast(); + if (child && child->name.is() && jump && + ExpressionAnalyzer::isSimple(jump)) { + redirectBranches(child, jump->name); + } + } + } + + void redirectBranches(Block* from, Name to) { + auto& branches = branchesToBlock[from]; + for (auto* branch : branches) { + if (BranchUtils::replacePossibleTarget(branch, from->name, to)) { + worked = true; + } + } + // if the jump is to another block then we can update the list, and + // maybe push it even more later + if (auto* newTarget = findBreakTarget(to)->dynCast()) { + for (auto* branch : branches) { + branchesToBlock[newTarget].push_back(branch); + } + } + } + + void finish(Function* func) { + if (worked) { + // by changing where brs go, we may change block types etc. + ReFinalize().walkFunctionInModule(func, getModule()); + } + } + }; + JumpThreader jumpThreader; + jumpThreader.setModule(getModule()); + jumpThreader.walkFunction(func); + jumpThreader.finish(func); + + // perform some final optimizations + struct FinalOptimizer : public PostWalker { + bool shrink; + PassOptions& passOptions; + + bool needUniqify = false; + + FinalOptimizer(PassOptions& passOptions) : passOptions(passOptions) {} + + void visitBlock(Block* curr) { + // if a block has an if br else br, we can un-conditionalize the latter, + // allowing the if to become a br_if. + // * note that if not in a block already, then we need to create a block + // for this, so not useful otherwise + // * note that this only happens at the end of a block, as code after + // the if is dead + // * note that we do this at the end, because un-conditionalizing can + // interfere with optimizeLoop()ing. + FeatureSet features = getModule()->features; + auto& list = curr->list; + for (Index i = 0; i < list.size(); i++) { + auto* iff = list[i]->dynCast(); + if (!iff || !iff->ifFalse) { + // if it lacked an if-false, it would already be a br_if, as that's + // the easy case + continue; + } + auto* ifTrueBreak = iff->ifTrue->dynCast(); + if (ifTrueBreak && !ifTrueBreak->condition && + canTurnIfIntoBrIf( + iff->condition, ifTrueBreak->value, passOptions, features)) { + // we are an if-else where the ifTrue is a break without a + // condition, so we can do this + ifTrueBreak->condition = iff->condition; + ifTrueBreak->finalize(); + list[i] = Builder(*getModule()).dropIfConcretelyTyped(ifTrueBreak); + ExpressionManipulator::spliceIntoBlock(curr, i + 1, iff->ifFalse); + continue; + } + // otherwise, perhaps we can flip the if + auto* ifFalseBreak = iff->ifFalse->dynCast(); + if (ifFalseBreak && !ifFalseBreak->condition && + canTurnIfIntoBrIf( + iff->condition, ifFalseBreak->value, passOptions, features)) { + ifFalseBreak->condition = + Builder(*getModule()).makeUnary(EqZInt32, iff->condition); + ifFalseBreak->finalize(); + list[i] = Builder(*getModule()).dropIfConcretelyTyped(ifFalseBreak); + ExpressionManipulator::spliceIntoBlock(curr, i + 1, iff->ifTrue); + continue; + } + } + if (list.size() >= 2) { + // combine/optimize adjacent br_ifs + a br (maybe _if) right after it + for (Index i = 0; i < list.size() - 1; i++) { + auto* br1 = list[i]->dynCast(); + // avoid unreachable brs, as they are dead code anyhow, and after + // merging them the outer scope could need type changes + if (!br1 || !br1->condition || br1->type == Type::unreachable) { + continue; + } + assert(!br1->value); + auto* br2 = list[i + 1]->dynCast(); + if (!br2 || br1->name != br2->name) { + continue; + } + assert(!br2->value); // same target as previous, which has no value + // a br_if and then a br[_if] with the same target right after it + if (br2->condition) { + if (shrink && br2->type != Type::unreachable) { + // Join adjacent br_ifs to the same target, making one br_if + // with a "selectified" condition that executes both. + if (!EffectAnalyzer(passOptions, features, br2->condition) + .hasSideEffects()) { + // it's ok to execute them both, do it + Builder builder(*getModule()); + br1->condition = + builder.makeBinary(OrInt32, br1->condition, br2->condition); + ExpressionManipulator::nop(br2); + } + } + } else { + // merge, we go there anyhow + Builder builder(*getModule()); + list[i] = builder.makeDrop(br1->condition); + } + } + // Combine adjacent br_ifs that test the same value into a br_table, + // when that makes sense. + tablify(curr); + // Pattern-patch ifs, recreating them when it makes sense. + restructureIf(curr); + } + } + + void visitSwitch(Switch* curr) { + if (BranchUtils::getUniqueTargets(curr).size() == 1) { + // This switch has just one target no matter what; replace with a br + // if we can (to do so, we must put the condition before a possible + // value). + if (!curr->value || EffectAnalyzer::canReorder(passOptions, + getModule()->features, + curr->condition, + curr->value)) { + Builder builder(*getModule()); + replaceCurrent(builder.makeSequence( + builder.makeDrop(curr->condition), // might have side effects + builder.makeBreak(curr->default_, curr->value))); + } + } + } + + // Restructuring of ifs: if we have + // (block $x + // (br_if $x (cond)) + // .., no other references to $x + // ) + // then we can turn that into (if (!cond) ..). + // Code size wise, we turn the block into an if (no change), and + // lose the br_if (-2). .. turns into the body of the if in the binary + // format. We need to flip the condition, which at worst adds 1. + // If the block has a return value, we can do something similar, removing + // the drop from the br_if and putting the if on the outside, + // (block $x + // (br_if $x (value) (cond)) + // .., no other references to $x + // ..final element.. + // ) + // => + // (if + // (cond) + // (value) ;; must not have side effects! + // (block + // .., no other references to $x + // ..final element.. + // ) + // ) + // This is beneficial as the block will likely go away in the binary + // format (the if arm is an implicit block), and the drop is removed. + void restructureIf(Block* curr) { + auto& list = curr->list; + // We should be called only on potentially-interesting lists. + assert(list.size() >= 2); + if (curr->name.is()) { + Break* br = nullptr; + Drop* drop = list[0]->dynCast(); + if (drop) { + br = drop->value->dynCast(); + } else { + br = list[0]->dynCast(); + } + // Check if the br is conditional and goes to the block. It may or may + // not have a value, depending on if it was dropped or not. If the + // type is unreachable that means it is not actually reached, which we + // can ignore. + if (br && br->condition && br->name == curr->name && + br->type != Type::unreachable) { + if (BranchUtils::BranchSeeker::count(curr, curr->name) == 1) { + // no other breaks to that name, so we can do this + if (!drop) { + assert(!br->value); + Builder builder(*getModule()); + replaceCurrent(builder.makeIf( + builder.makeUnary(EqZInt32, br->condition), curr)); + ExpressionManipulator::nop(br); + curr->finalize(curr->type); + } else { + // If the items we move around have side effects, we can't do + // this. + // TODO: we could use a select, in some cases..? + FeatureSet features = getModule()->features; + if (!EffectAnalyzer(passOptions, features, br->value) + .hasSideEffects() && + !EffectAnalyzer(passOptions, features, br->condition) + .hasSideEffects()) { + ExpressionManipulator::nop(list[0]); + Builder builder(*getModule()); + replaceCurrent( + builder.makeIf(br->condition, br->value, curr)); + } + } + } + } + } + } + + void visitIf(If* curr) { + // we may have simplified ifs enough to turn them into selects + if (auto* select = selectify(curr)) { + replaceCurrent(select); + } + } + + // Convert an if into a select, if possible and beneficial to do so. + Select* selectify(If* iff) { + if (!iff->ifFalse || !iff->ifTrue->type.isSingle() || + !iff->ifFalse->type.isSingle()) { + return nullptr; + } + // This is always helpful for code size, but can be a tradeoff with + // performance as we run both code paths. So when shrinking we always + // try to do this, but otherwise must consider more carefully. + if (tooCostlyToRunUnconditionally( + passOptions, iff->ifTrue, iff->ifFalse)) { + return nullptr; + } + // Check if side effects allow this. + FeatureSet features = getModule()->features; + EffectAnalyzer condition(passOptions, features, iff->condition); + if (!condition.hasSideEffects()) { + EffectAnalyzer ifTrue(passOptions, features, iff->ifTrue); + if (!ifTrue.hasSideEffects()) { + EffectAnalyzer ifFalse(passOptions, features, iff->ifFalse); + if (!ifFalse.hasSideEffects()) { + return Builder(*getModule()) + .makeSelect(iff->condition, iff->ifTrue, iff->ifFalse); + } + } + } + return nullptr; + } + + void visitLocalSet(LocalSet* curr) { + // Sets of an if can be optimized in various ways that remove part of + // the if branching, or all of it. + // The optimizations we can do here can recurse and call each + // other, so pass around a pointer to the output. + optimizeSetIf(getCurrentPointer()); + } + + void optimizeSetIf(Expression** currp) { + if (optimizeSetIfWithBrArm(currp)) { + return; + } + if (optimizeSetIfWithCopyArm(currp)) { + return; + } + } + + // If one arm is a br, we prefer a br_if and the set later: + // (local.set $x + // (if (result i32) + // (..condition..) + // (br $somewhere) + // (..result) + // ) + // ) + // => + // (br_if $somewhere + // (..condition..) + // ) + // (local.set $x + // (..result) + // ) + // TODO: handle a condition in the br? need to watch for side effects + bool optimizeSetIfWithBrArm(Expression** currp) { + auto* set = (*currp)->cast(); + auto* iff = set->value->dynCast(); + if (!iff || !iff->type.isConcrete() || + !iff->condition->type.isConcrete()) { + return false; + } + auto tryToOptimize = + [&](Expression* one, Expression* two, bool flipCondition) { + if (one->type == Type::unreachable && + two->type != Type::unreachable) { + if (auto* br = one->dynCast()) { + if (ExpressionAnalyzer::isSimple(br)) { + // Wonderful, do it! + Builder builder(*getModule()); + if (flipCondition) { + builder.flip(iff); + } + br->condition = iff->condition; + br->finalize(); + set->value = two; + auto* block = builder.makeSequence(br, set); + *currp = block; + // Recurse on the set, which now has a new value. + optimizeSetIf(&block->list[1]); + return true; + } + } + } + return false; + }; + return tryToOptimize(iff->ifTrue, iff->ifFalse, false) || + tryToOptimize(iff->ifFalse, iff->ifTrue, true); + } + + // If one arm is a get of the same outer set, it is a copy which + // we can remove. If this is not a tee, then we remove the get + // as well as the if-else opcode in the binary format, which is + // great: + // (local.set $x + // (if (result i32) + // (..condition..) + // (..result) + // (local.get $x) + // ) + // ) + // => + // (if + // (..condition..) + // (local.set $x + // (..result) + // ) + // ) + // If this is a tee, then we can do the same operation but + // inside a block, and keep the get: + // (local.tee $x + // (if (result i32) + // (..condition..) + // (..result) + // (local.get $x) + // ) + // ) + // => + // (block (result i32) + // (if + // (..condition..) + // (local.set $x + // (..result) + // ) + // ) + // (local.get $x) + // ) + // We save the if-else opcode, and add the block's opcodes. + // This may be detrimental, however, often the block can be + // merged or eliminated given the outside scope, and we + // removed one of the if branches. + bool optimizeSetIfWithCopyArm(Expression** currp) { + auto* set = (*currp)->cast(); + auto* iff = set->value->dynCast(); + if (!iff || !iff->type.isConcrete() || + !iff->condition->type.isConcrete()) { + return false; + } + Builder builder(*getModule()); + LocalGet* get = iff->ifTrue->dynCast(); + if (get && get->index == set->index) { + builder.flip(iff); + } else { + get = iff->ifFalse->dynCast(); + if (get && get->index != set->index) { + get = nullptr; + } + } + if (!get) { + return false; + } + // We can do it! + bool tee = set->isTee(); + assert(set->index == get->index); + assert(iff->ifFalse == get); + set->value = iff->ifTrue; + set->finalize(); + iff->ifTrue = set; + iff->ifFalse = nullptr; + iff->finalize(); + Expression* replacement = iff; + if (tee) { + set->makeSet(); + // We need a block too. + replacement = builder.makeSequence(iff, + get // reuse the get + ); + } + *currp = replacement; + // Recurse on the set, which now has a new value. + optimizeSetIf(&iff->ifTrue); + return true; + } + + // (br_if)+ => br_table + // we look for the specific pattern of + // (br_if ..target1.. + // (i32.eq + // (..input..) + // (i32.const ..value1..) + // ) + // ) + // (br_if ..target2.. + // (i32.eq + // (..input..) + // (i32.const ..value2..) + // ) + // ) + // TODO: consider also looking at <= etc. and not just eq + void tablify(Block* block) { + auto& list = block->list; + if (list.size() <= 1) { + return; + } + + // Heuristics. These are slightly inspired by the constants from the + // asm.js backend. + + // How many br_ifs we need to see to consider doing this + const uint32_t MIN_NUM = 3; + // How much of a range of values is definitely too big + const uint32_t MAX_RANGE = 1024; + // Multiplied by the number of br_ifs, then compared to the range. When + // this is high, we allow larger ranges. + const uint32_t NUM_TO_RANGE_FACTOR = 3; + + // check if the input is a proper br_if on an i32.eq of a condition + // value to a const, and the const is in the proper range, + // [0-int32_max), to avoid overflow concerns. returns the br_if if so, + // or nullptr otherwise + auto getProperBrIf = [](Expression* curr) -> Break* { + auto* br = curr->dynCast(); + if (!br) { + return nullptr; + } + if (!br->condition || br->value) { + return nullptr; + } + if (br->type != Type::none) { + // no value, so can be unreachable or none. ignore unreachable ones, + // dce will clean it up + return nullptr; + } + auto* binary = br->condition->dynCast(); + if (!binary) { + return nullptr; + } + if (binary->op != EqInt32) { + return nullptr; + } + auto* c = binary->right->dynCast(); + if (!c) { + return nullptr; + } + uint32_t value = c->value.geti32(); + if (value >= uint32_t(std::numeric_limits::max())) { + return nullptr; + } + return br; + }; + + // check if the input is a proper br_if + // and returns the condition if so, or nullptr otherwise + auto getProperBrIfConditionValue = + [&getProperBrIf](Expression* curr) -> Expression* { + auto* br = getProperBrIf(curr); + if (!br) { + return nullptr; + } + return br->condition->cast()->left; + }; + + // returns the constant value, as a uint32_t + auto getProperBrIfConstant = + [&getProperBrIf](Expression* curr) -> uint32_t { + return getProperBrIf(curr) + ->condition->cast() + ->right->cast() + ->value.geti32(); + }; + Index start = 0; + while (start < list.size() - 1) { + auto* conditionValue = getProperBrIfConditionValue(list[start]); + if (!conditionValue) { + start++; + continue; + } + // if the condition has side effects, we can't replace many + // appearances of it with a single one + if (EffectAnalyzer(passOptions, getModule()->features, conditionValue) + .hasSideEffects()) { + start++; + continue; + } + // look for a "run" of br_ifs with all the same conditionValue, and + // having unique constants (an overlapping constant could be handled, + // just the first branch is taken, but we can't remove the other br_if + // (it may be the only branch keeping a block reachable), which may + // make this bad for code size. + Index end = start + 1; + std::unordered_set usedConstants; + usedConstants.insert(getProperBrIfConstant(list[start])); + while (end < list.size() && + ExpressionAnalyzer::equal( + getProperBrIfConditionValue(list[end]), conditionValue)) { + if (!usedConstants.insert(getProperBrIfConstant(list[end])) + .second) { + // this constant already appeared + break; + } + end++; + } + auto num = end - start; + if (num >= 2 && num >= MIN_NUM) { + // we found a suitable range, [start, end), containing more than 1 + // element. let's see if it's worth it + auto min = getProperBrIfConstant(list[start]); + auto max = min; + for (Index i = start + 1; i < end; i++) { + auto* curr = list[i]; + min = std::min(min, getProperBrIfConstant(curr)); + max = std::max(max, getProperBrIfConstant(curr)); + } + uint32_t range = max - min; + // decision time + if (range <= MAX_RANGE && range <= num * NUM_TO_RANGE_FACTOR) { + // great! let's do this + std::unordered_set usedNames; + for (Index i = start; i < end; i++) { + usedNames.insert(getProperBrIf(list[i])->name); + } + // we need a name for the default too + Name defaultName; + Index i = 0; + while (1) { + defaultName = "tablify|" + std::to_string(i++); + if (usedNames.count(defaultName) == 0) { + break; + } + } + std::vector table; + for (Index i = start; i < end; i++) { + auto name = getProperBrIf(list[i])->name; + auto index = getProperBrIfConstant(list[i]); + index -= min; + while (table.size() <= index) { + table.push_back(defaultName); + } + // we should have made sure there are no overlaps + assert(table[index] == defaultName); + table[index] = name; + } + Builder builder(*getModule()); + // the table and condition are offset by the min + if (min != 0) { + conditionValue = builder.makeBinary( + SubInt32, conditionValue, builder.makeConst(int32_t(min))); + } + list[end - 1] = builder.makeBlock( + defaultName, + builder.makeSwitch(table, defaultName, conditionValue)); + for (Index i = start; i < end - 1; i++) { + ExpressionManipulator::nop(list[i]); + } + // the defaultName may exist elsewhere in this function, + // uniquify it later + needUniqify = true; + } + } + start = end; + } + } + }; + FinalOptimizer finalOptimizer(getPassOptions()); + finalOptimizer.setModule(getModule()); + finalOptimizer.shrink = getPassRunner()->options.shrinkLevel > 0; + finalOptimizer.walkFunction(func); + if (finalOptimizer.needUniqify) { + wasm::UniqueNameMapper::uniquify(func->body); + } + } +}; + +Pass* createRemoveUnusedBrsPass() { return new RemoveUnusedBrs(); } + +} // namespace wasm diff --git a/binaryen/src/passes/RemoveUnusedModuleElements.cpp b/binaryen/src/passes/RemoveUnusedModuleElements.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/passes/RemoveUnusedModuleElements.cpp @@ -0,0 +1,243 @@ +/* + * Copyright 2016 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// Removes module elements that are are never used: functions, globals, and +// events, which may be imported or not, and function types (which we merge and +// remove if unneeded) +// + +#include + +#include "asm_v_wasm.h" +#include "ir/module-utils.h" +#include "ir/utils.h" +#include "pass.h" +#include "wasm.h" + +namespace wasm { + +enum class ModuleElementKind { Function, Global, Event }; + +typedef std::pair ModuleElement; + +// Finds reachabilities +// TODO: use Effects to determine if a memory is used + +struct ReachabilityAnalyzer : public PostWalker { + Module* module; + std::vector queue; + std::set reachable; + bool usesMemory = false; + bool usesTable = false; + + ReachabilityAnalyzer(Module* module, const std::vector& roots) + : module(module) { + queue = roots; + // Globals used in memory/table init expressions are also roots + for (auto& segment : module->memory.segments) { + if (!segment.isPassive) { + walk(segment.offset); + } + } + for (auto& segment : module->table.segments) { + walk(segment.offset); + } + // main loop + while (queue.size()) { + auto& curr = queue.back(); + queue.pop_back(); + if (reachable.count(curr) == 0) { + reachable.insert(curr); + if (curr.first == ModuleElementKind::Function) { + // if not an import, walk it + auto* func = module->getFunction(curr.second); + if (!func->imported()) { + walk(func->body); + } + } else if (curr.first == ModuleElementKind::Global) { + // if not imported, it has an init expression we need to walk + auto* global = module->getGlobal(curr.second); + if (!global->imported()) { + walk(global->init); + } + } + } + } + } + + void visitCall(Call* curr) { + if (reachable.count( + ModuleElement(ModuleElementKind::Function, curr->target)) == 0) { + queue.emplace_back(ModuleElementKind::Function, curr->target); + } + } + void visitCallIndirect(CallIndirect* curr) { usesTable = true; } + + void visitGlobalGet(GlobalGet* curr) { + if (reachable.count(ModuleElement(ModuleElementKind::Global, curr->name)) == + 0) { + queue.emplace_back(ModuleElementKind::Global, curr->name); + } + } + void visitGlobalSet(GlobalSet* curr) { + if (reachable.count(ModuleElement(ModuleElementKind::Global, curr->name)) == + 0) { + queue.emplace_back(ModuleElementKind::Global, curr->name); + } + } + + void visitLoad(Load* curr) { usesMemory = true; } + void visitStore(Store* curr) { usesMemory = true; } + void visitAtomicCmpxchg(AtomicCmpxchg* curr) { usesMemory = true; } + void visitAtomicRMW(AtomicRMW* curr) { usesMemory = true; } + void visitAtomicWait(AtomicWait* curr) { usesMemory = true; } + void visitAtomicNotify(AtomicNotify* curr) { usesMemory = true; } + void visitAtomicFence(AtomicFence* curr) { usesMemory = true; } + void visitMemoryInit(MemoryInit* curr) { usesMemory = true; } + void visitDataDrop(DataDrop* curr) { usesMemory = true; } + void visitMemoryCopy(MemoryCopy* curr) { usesMemory = true; } + void visitMemoryFill(MemoryFill* curr) { usesMemory = true; } + void visitMemorySize(MemorySize* curr) { usesMemory = true; } + void visitMemoryGrow(MemoryGrow* curr) { usesMemory = true; } + void visitRefFunc(RefFunc* curr) { + if (reachable.count( + ModuleElement(ModuleElementKind::Function, curr->func)) == 0) { + queue.emplace_back(ModuleElementKind::Function, curr->func); + } + } + void visitThrow(Throw* curr) { + if (reachable.count(ModuleElement(ModuleElementKind::Event, curr->event)) == + 0) { + queue.emplace_back(ModuleElementKind::Event, curr->event); + } + } + void visitBrOnExn(BrOnExn* curr) { + if (reachable.count(ModuleElement(ModuleElementKind::Event, curr->event)) == + 0) { + queue.emplace_back(ModuleElementKind::Event, curr->event); + } + } +}; + +struct RemoveUnusedModuleElements : public Pass { + bool rootAllFunctions; + + RemoveUnusedModuleElements(bool rootAllFunctions) + : rootAllFunctions(rootAllFunctions) {} + + void run(PassRunner* runner, Module* module) override { + std::vector roots; + // Module start is a root. + if (module->start.is()) { + auto startFunction = module->getFunction(module->start); + // Can be skipped if the start function is empty. + if (startFunction->body->is()) { + module->start.clear(); + } else { + roots.emplace_back(ModuleElementKind::Function, module->start); + } + } + // If told to, root all the functions + if (rootAllFunctions) { + ModuleUtils::iterDefinedFunctions(*module, [&](Function* func) { + roots.emplace_back(ModuleElementKind::Function, func->name); + }); + } + // Exports are roots. + bool exportsMemory = false; + bool exportsTable = false; + for (auto& curr : module->exports) { + if (curr->kind == ExternalKind::Function) { + roots.emplace_back(ModuleElementKind::Function, curr->value); + } else if (curr->kind == ExternalKind::Global) { + roots.emplace_back(ModuleElementKind::Global, curr->value); + } else if (curr->kind == ExternalKind::Event) { + roots.emplace_back(ModuleElementKind::Event, curr->value); + } else if (curr->kind == ExternalKind::Memory) { + exportsMemory = true; + } else if (curr->kind == ExternalKind::Table) { + exportsTable = true; + } + } + // Check for special imports, which are roots. + bool importsMemory = false; + bool importsTable = false; + if (module->memory.imported()) { + importsMemory = true; + } + if (module->table.imported()) { + importsTable = true; + } + // For now, all functions that can be called indirectly are marked as roots. + for (auto& segment : module->table.segments) { + for (auto& curr : segment.data) { + roots.emplace_back(ModuleElementKind::Function, curr); + } + } + // Compute reachability starting from the root set. + ReachabilityAnalyzer analyzer(module, roots); + // Remove unreachable elements. + module->removeFunctions([&](Function* curr) { + return analyzer.reachable.count( + ModuleElement(ModuleElementKind::Function, curr->name)) == 0; + }); + module->removeGlobals([&](Global* curr) { + return analyzer.reachable.count( + ModuleElement(ModuleElementKind::Global, curr->name)) == 0; + }); + module->removeEvents([&](Event* curr) { + return analyzer.reachable.count( + ModuleElement(ModuleElementKind::Event, curr->name)) == 0; + }); + // Handle the memory and table + if (!exportsMemory && !analyzer.usesMemory) { + if (!importsMemory) { + // The memory is unobservable to the outside, we can remove the + // contents. + module->memory.segments.clear(); + } + if (module->memory.segments.empty()) { + module->memory.exists = false; + module->memory.module = module->memory.base = Name(); + module->memory.initial = 0; + module->memory.max = 0; + } + } + if (!exportsTable && !analyzer.usesTable) { + if (!importsTable) { + // The table is unobservable to the outside, we can remove the contents. + module->table.segments.clear(); + } + if (module->table.segments.empty()) { + module->table.exists = false; + module->table.module = module->table.base = Name(); + module->table.initial = 0; + module->table.max = 0; + } + } + } +}; + +Pass* createRemoveUnusedModuleElementsPass() { + return new RemoveUnusedModuleElements(false); +} + +Pass* createRemoveUnusedNonFunctionModuleElementsPass() { + return new RemoveUnusedModuleElements(true); +} + +} // namespace wasm diff --git a/binaryen/src/passes/RemoveUnusedNames.cpp b/binaryen/src/passes/RemoveUnusedNames.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/passes/RemoveUnusedNames.cpp @@ -0,0 +1,105 @@ +/* + * Copyright 2015 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// Removes names from locations that are never branched to, and +// merge names when possible (by merging their blocks) +// + +#include +#include + +namespace wasm { + +struct RemoveUnusedNames : public WalkerPass> { + bool isFunctionParallel() override { return true; } + + Pass* create() override { return new RemoveUnusedNames; } + + // We maintain a list of branches that we saw in children, then when we reach + // a parent block, we know if it was branched to + std::map> branchesSeen; + + void visitBreak(Break* curr) { branchesSeen[curr->name].insert(curr); } + + void visitSwitch(Switch* curr) { + for (auto name : curr->targets) { + branchesSeen[name].insert(curr); + } + branchesSeen[curr->default_].insert(curr); + } + + void visitBrOnExn(BrOnExn* curr) { branchesSeen[curr->name].insert(curr); } + + void handleBreakTarget(Name& name) { + if (name.is()) { + if (branchesSeen.find(name) == branchesSeen.end()) { + name = Name(); + } else { + branchesSeen.erase(name); + } + } + } + + void visitBlock(Block* curr) { + if (curr->name.is() && curr->list.size() == 1) { + auto* child = curr->list[0]->dynCast(); + if (child && child->name.is() && child->type == curr->type) { + // we have just one child, this block, so breaking out of it goes to the + // same place as breaking out of us, we just need one name (and block) + auto& branches = branchesSeen[curr->name]; + for (auto* branch : branches) { + if (Break* br = branch->dynCast()) { + if (br->name == curr->name) { + br->name = child->name; + } + } else if (Switch* sw = branch->dynCast()) { + for (auto& target : sw->targets) { + if (target == curr->name) { + target = child->name; + } + } + if (sw->default_ == curr->name) { + sw->default_ = child->name; + } + } else if (BrOnExn* br = branch->dynCast()) { + if (br->name == curr->name) { + br->name = child->name; + } + } else { + WASM_UNREACHABLE("unexpected expr type"); + } + } + child->finalize(child->type); + replaceCurrent(child); + } + } + handleBreakTarget(curr->name); + } + + void visitLoop(Loop* curr) { + handleBreakTarget(curr->name); + if (!curr->name.is() && curr->body->type == curr->type) { + replaceCurrent(curr->body); + } + } + + void visitFunction(Function* curr) { assert(branchesSeen.empty()); } +}; + +Pass* createRemoveUnusedNamesPass() { return new RemoveUnusedNames(); } + +} // namespace wasm diff --git a/binaryen/src/passes/ReorderFunctions.cpp b/binaryen/src/passes/ReorderFunctions.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/passes/ReorderFunctions.cpp @@ -0,0 +1,93 @@ +/* + * Copyright 2016 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// Sorts functions by their static use count. This helps reduce the size of wasm +// binaries because fewer bytes are needed to encode references to frequently +// used functions. +// +// This may incur a tradeoff, though, as while it reduces binary size, it may +// increase gzip size. This might be because the new order has the functions in +// a less beneficial position for compression, that is, mutually-compressible +// functions are no longer together (when they were before, in the original +// order, the has some natural tendency one way or the other). TODO: investigate +// similarity ordering here. +// + +#include + +#include +#include + +namespace wasm { + +typedef std::unordered_map> NameCountMap; + +struct CallCountScanner : public WalkerPass> { + bool isFunctionParallel() override { return true; } + + CallCountScanner(NameCountMap* counts) : counts(counts) {} + + CallCountScanner* create() override { return new CallCountScanner(counts); } + + void visitCall(Call* curr) { + // can't add a new element in parallel + assert(counts->count(curr->target) > 0); + (*counts)[curr->target]++; + } + +private: + NameCountMap* counts; +}; + +struct ReorderFunctions : public Pass { + void run(PassRunner* runner, Module* module) override { + NameCountMap counts; + // fill in info, as we operate on it in parallel (each function to its own + // entry) + for (auto& func : module->functions) { + counts[func->name]; + } + // find counts on function calls + CallCountScanner(&counts).run(runner, module); + // find counts on global usages + if (module->start.is()) { + counts[module->start]++; + } + for (auto& curr : module->exports) { + counts[curr->value]++; + } + for (auto& segment : module->table.segments) { + for (auto& curr : segment.data) { + counts[curr]++; + } + } + // sort + std::sort(module->functions.begin(), + module->functions.end(), + [&counts](const std::unique_ptr& a, + const std::unique_ptr& b) -> bool { + if (counts[a->name] == counts[b->name]) { + return strcmp(a->name.str, b->name.str) > 0; + } + return counts[a->name] > counts[b->name]; + }); + } +}; + +Pass* createReorderFunctionsPass() { return new ReorderFunctions(); } + +} // namespace wasm diff --git a/binaryen/src/passes/ReorderLocals.cpp b/binaryen/src/passes/ReorderLocals.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/passes/ReorderLocals.cpp @@ -0,0 +1,162 @@ +/* + * Copyright 2016 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// Sorts locals by access frequency. +// +// Secondarily, sort by first appearance. This canonicalizes the order. +// +// While sorting, we remove locals that have no uses at all. +// + +#include + +#include +#include + +namespace wasm { + +struct ReorderLocals : public WalkerPass> { + bool isFunctionParallel() override { return true; } + + Pass* create() override { return new ReorderLocals; } + + // local index => times it is used + std::vector counts; + // local index => how many locals we saw before this one, before a use of + // this one appeared. that is, one local has 1, another has 2, and so forth, + // in the order in which we saw the first uses of them (we use "0" to mark + // locals we have not yet seen). + std::vector firstUses; + Index firstUseIndex = 1; + + enum { Unseen = 0 }; + + void doWalkFunction(Function* curr) { + if (curr->getNumVars() == 0) { + return; // nothing to do. All locals are parameters + } + Index num = curr->getNumLocals(); + counts.resize(num); + std::fill(counts.begin(), counts.end(), 0); + firstUses.resize(num); + std::fill(firstUses.begin(), firstUses.end(), Unseen); + // Gather information about local usages. + walk(curr->body); + // Use the information about local usages. + std::vector newToOld(num); + for (size_t i = 0; i < num; i++) { + newToOld[i] = i; + } + // sort, keeping params in front (where they will not be moved) + sort( + newToOld.begin(), newToOld.end(), [this, curr](Index a, Index b) -> bool { + if (curr->isParam(a) && !curr->isParam(b)) { + return true; + } + if (curr->isParam(b) && !curr->isParam(a)) { + return false; + } + if (curr->isParam(b) && curr->isParam(a)) { + return a < b; + } + if (counts[a] == counts[b]) { + if (counts[a] == 0) { + return a < b; + } + return firstUses[a] < firstUses[b]; + } + return counts[a] > counts[b]; + }); + // sorting left params in front, perhaps slightly reordered. verify and fix. + size_t numParams = curr->sig.params.size(); + for (size_t i = 0; i < numParams; i++) { + assert(newToOld[i] < numParams); + newToOld[i] = i; + } + // sort vars, and drop unused ones + std::vector oldVars; + std::swap(oldVars, curr->vars); + for (size_t i = curr->getVarIndexBase(); i < newToOld.size(); i++) { + Index index = newToOld[i]; + if (counts[index] > 0) { + curr->vars.push_back(oldVars[index - curr->getVarIndexBase()]); + } else { + newToOld.resize(i); + break; + } + } + counts.clear(); + std::vector oldToNew; + oldToNew.resize(num); + for (size_t i = 0; i < newToOld.size(); i++) { + if (curr->isParam(i)) { + oldToNew[i] = i; + } else { + oldToNew[newToOld[i]] = i; + } + } + // apply the renaming to AST nodes + struct ReIndexer : public PostWalker { + Function* func; + std::vector& oldToNew; + + ReIndexer(Function* func, std::vector& oldToNew) + : func(func), oldToNew(oldToNew) {} + + void visitLocalGet(LocalGet* curr) { + curr->index = oldToNew[curr->index]; + } + + void visitLocalSet(LocalSet* curr) { + curr->index = oldToNew[curr->index]; + } + }; + ReIndexer reIndexer(curr, oldToNew); + reIndexer.walk(curr->body); + // apply to the names + auto oldLocalNames = curr->localNames; + auto oldLocalIndices = curr->localIndices; + curr->localNames.clear(); + curr->localIndices.clear(); + for (size_t i = 0; i < newToOld.size(); i++) { + auto iter = oldLocalNames.find(newToOld[i]); + if (iter != oldLocalNames.end()) { + auto old = iter->second; + curr->localNames[i] = old; + curr->localIndices[old] = i; + } + } + } + + void visitLocalGet(LocalGet* curr) { + counts[curr->index]++; + if (firstUses[curr->index] == Unseen) { + firstUses[curr->index] = firstUseIndex++; + } + } + + void visitLocalSet(LocalSet* curr) { + counts[curr->index]++; + if (firstUses[curr->index] == Unseen) { + firstUses[curr->index] = firstUseIndex++; + } + } +}; + +Pass* createReorderLocalsPass() { return new ReorderLocals(); } + +} // namespace wasm diff --git a/binaryen/src/passes/ReplaceStackPointer.cpp b/binaryen/src/passes/ReplaceStackPointer.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/passes/ReplaceStackPointer.cpp @@ -0,0 +1,103 @@ +/* + * Copyright 2020 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// Convert llvm's stack pointer usage from from global.get/global.set into +// cals to external stackSave/stackRestore. +// This is needed to emscripten SIDE_MODULE code where mutable global imports +// are not yet permitted by default. +// + +#include "abi/js.h" +#include "ir/import-utils.h" +#include "pass.h" +#include "support/debug.h" +#include "wasm-emscripten.h" + +#define DEBUG_TYPE "replace-stack-pointer" + +namespace wasm { + +static Name STACK_SAVE("stackSave"); +static Name STACK_RESTORE("stackRestore"); + +struct ReplaceStackPointer + : public WalkerPass> { + void visitGlobalGet(GlobalGet* curr) { + if (getModule()->getGlobalOrNull(curr->name) == stackPointer) { + needStackSave = true; + if (!builder) { + builder = make_unique(*getModule()); + } + replaceCurrent(builder->makeCall(STACK_SAVE, {}, Type::i32)); + } + } + + void visitGlobalSet(GlobalSet* curr) { + if (getModule()->getGlobalOrNull(curr->name) == stackPointer) { + needStackRestore = true; + if (!builder) { + builder = make_unique(*getModule()); + } + replaceCurrent( + builder->makeCall(STACK_RESTORE, {curr->value}, Type::none)); + } + } + + void doWalkModule(Module* module) { + stackPointer = getStackPointerGlobal(*module); + if (!stackPointer) { + BYN_DEBUG(std::cerr << "no stack pointer found\n"); + return; + } + BYN_DEBUG(std::cerr << "stack pointer found\n"); + super::doWalkModule(module); + if (needStackSave) { + ensureFunctionImport( + module, STACK_SAVE, Signature(Type::none, Type::i32)); + } + if (needStackRestore) { + ensureFunctionImport( + module, STACK_RESTORE, Signature(Type::i32, Type::none)); + } + // Finally remove the stack pointer global itself. This avoids importing + // a mutable global. + module->removeGlobal(stackPointer->name); + } + + void ensureFunctionImport(Module* module, Name name, Signature sig) { + ImportInfo info(*module); + if (info.getImportedFunction(ENV, name)) { + return; + } + auto import = new Function; + import->name = name; + import->module = ENV; + import->base = name; + import->sig = sig; + module->addFunction(import); + } + +private: + std::unique_ptr builder; + Global* stackPointer = nullptr; + bool needStackSave = false; + bool needStackRestore = false; +}; + +Pass* createReplaceStackPointerPass() { return new ReplaceStackPointer; } + +} // namespace wasm diff --git a/binaryen/src/passes/RoundTrip.cpp b/binaryen/src/passes/RoundTrip.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/passes/RoundTrip.cpp @@ -0,0 +1,52 @@ +/* + * Copyright 2019 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// Write the module to binary, and load it from there. This is useful in +// testing to check for the effects of roundtripping in a single wasm-opt +// parameter. +// + +#include "ir/module-utils.h" +#include "pass.h" +#include "wasm-binary.h" +#include "wasm.h" + +using namespace std; + +namespace wasm { + +struct RoundTrip : public Pass { + void run(PassRunner* runner, Module* module) override { + BufferWithRandomAccess buffer; + // Save features, which would not otherwise make it through a round trip if + // the target features section has been stripped. + auto features = module->features; + // Write, clear, and read the module + WasmBinaryWriter(module, buffer).write(); + ModuleUtils::clearModule(*module); + auto input = buffer.getAsChars(); + WasmBinaryBuilder parser(*module, input); + parser.setDWARF(runner->options.debugInfo); + parser.read(); + // Reapply features + module->features = features; + } +}; + +Pass* createRoundTripPass() { return new RoundTrip(); } + +} // namespace wasm diff --git a/binaryen/src/passes/SSAify.cpp b/binaryen/src/passes/SSAify.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/passes/SSAify.cpp @@ -0,0 +1,201 @@ +/* + * Copyright 2016 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// Transforms code into SSA form. That ensures each variable has a +// single assignment. +// +// Note that "SSA form" usually means SSA + phis. This pass does not +// create phis, we still emit something in our AST, which does not +// have a phi instruction. What we emit when control flow joins +// require more than one input to a value is multiple assignments +// to the same local, with the SSA guarantee that one and only one +// of those assignments will arrive at the uses of that "merge local". +// TODO: consider adding a "proper" phi node to the AST, that passes +// can utilize +// +// There is also a "no-merge" variant of this pass. That will ignore +// sets leading to merges, that is, it only creates new SSA indexes +// for sets whose gets have just that set, e.g. +// +// x = .. +// f(x, x) +// x = .. +// g(x, x) +// => +// x = .. +// f(x, x) +// x' = .. +// g(x', x') +// +// This "untangles" local indexes in a way that helps other passes, +// while not creating copies with overlapping lifetimes that can +// lead to a code size increase. In particular, the new variables +// added by ssa-nomerge can be easily removed by the coalesce-locals +// pass. +// + +#include + +#include "ir/find_all.h" +#include "ir/literal-utils.h" +#include "ir/local-graph.h" +#include "pass.h" +#include "support/permutations.h" +#include "wasm-builder.h" +#include "wasm.h" + +namespace wasm { + +// A set we know is impossible / not in the ast +static LocalSet IMPOSSIBLE_SET; + +// Tracks assignments to locals, assuming single-assignment form, i.e., +// each assignment creates a new variable. + +struct SSAify : public Pass { + bool isFunctionParallel() override { return true; } + + Pass* create() override { return new SSAify(allowMerges); } + + SSAify(bool allowMerges) : allowMerges(allowMerges) {} + + bool allowMerges; + + Module* module; + Function* func; + // things we add to the function prologue + std::vector functionPrepends; + + void + runOnFunction(PassRunner* runner, Module* module_, Function* func_) override { + module = module_; + func = func_; + LocalGraph graph(func); + graph.computeInfluences(); + graph.computeSSAIndexes(); + // create new local indexes, one for each set + createNewIndexes(graph); + // we now know the sets for each get, and can compute get indexes and handle + // phis + computeGetsAndPhis(graph); + // add prepends to function + addPrepends(); + } + + void createNewIndexes(LocalGraph& graph) { + FindAll sets(func->body); + for (auto* set : sets.list) { + // Indexes already in SSA form do not need to be modified - there is + // already just one set for that index. Otherwise, use a new index, unless + // merges are disallowed. + if (!graph.isSSA(set->index) && (allowMerges || !hasMerges(set, graph))) { + set->index = addLocal(func->getLocalType(set->index)); + } + } + } + + bool hasMerges(LocalSet* set, LocalGraph& graph) { + for (auto* get : graph.setInfluences[set]) { + if (graph.getSetses[get].size() > 1) { + return true; + } + } + return false; + } + + void computeGetsAndPhis(LocalGraph& graph) { + FindAll gets(func->body); + for (auto* get : gets.list) { + auto& sets = graph.getSetses[get]; + if (sets.size() == 0) { + continue; // unreachable, ignore + } + if (sets.size() == 1) { + // easy, just one set, use its index + auto* set = *sets.begin(); + if (set) { + get->index = set->index; + } else { + // no set, assign param or zero + if (func->isParam(get->index)) { + // leave it, it's fine + } else { + // zero it out + (*graph.locations[get]) = + LiteralUtils::makeZero(get->type, *module); + } + } + continue; + } + if (!allowMerges) { + continue; + } + // more than 1 set, need a phi: a new local written to at each of the sets + auto new_ = addLocal(get->type); + auto old = get->index; + get->index = new_; + Builder builder(*module); + // write to the local in each of our sets + for (auto* set : sets) { + if (set) { + // a set exists, just add a tee of its value + auto* value = set->value; + auto* tee = builder.makeLocalTee(new_, value, get->type); + set->value = tee; + // the value may have been something we tracked the location + // of. if so, update that, since we moved it into the tee + if (graph.locations.count(value) > 0) { + assert(graph.locations[value] == &set->value); + graph.locations[value] = &tee->value; + } + } else { + // this is a param or the zero init value. + if (func->isParam(old)) { + // we add a set with the proper + // param value at the beginning of the function + auto* set = builder.makeLocalSet( + new_, builder.makeLocalGet(old, func->getLocalType(old))); + functionPrepends.push_back(set); + } else { + // this is a zero init, so we don't need to do anything actually + } + } + } + } + } + + Index addLocal(Type type) { return Builder::addVar(func, type); } + + void addPrepends() { + if (functionPrepends.size() > 0) { + Builder builder(*module); + auto* block = builder.makeBlock(); + for (auto* pre : functionPrepends) { + block->list.push_back(pre); + } + block->list.push_back(func->body); + block->finalize(func->body->type); + func->body = block; + } + } +}; + +Pass* createSSAifyPass() { return new SSAify(true); } + +Pass* createSSAifyNoMergePass() { return new SSAify(false); } + +} // namespace wasm diff --git a/binaryen/src/passes/SafeHeap.cpp b/binaryen/src/passes/SafeHeap.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/passes/SafeHeap.cpp @@ -0,0 +1,372 @@ +/* + * Copyright 2016 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// Instruments code to check for incorrect heap access. This checks +// for dereferencing 0 (null pointer access), reading past the valid +// top of sbrk()-addressible memory, and incorrect alignment notation. +// + +#include "asm_v_wasm.h" +#include "asmjs/shared-constants.h" +#include "ir/bits.h" +#include "ir/import-utils.h" +#include "ir/load-utils.h" +#include "pass.h" +#include "wasm-builder.h" +#include "wasm.h" + +namespace wasm { + +static const Name DYNAMICTOP_PTR_IMPORT("DYNAMICTOP_PTR"); +static const Name GET_SBRK_PTR("emscripten_get_sbrk_ptr"); +static const Name SBRK("sbrk"); +static const Name SEGFAULT_IMPORT("segfault"); +static const Name ALIGNFAULT_IMPORT("alignfault"); + +static Name getLoadName(Load* curr) { + std::string ret = "SAFE_HEAP_LOAD_"; + ret += curr->type.toString(); + ret += "_" + std::to_string(curr->bytes) + "_"; + if (LoadUtils::isSignRelevant(curr) && !curr->signed_) { + ret += "U_"; + } + if (curr->isAtomic) { + ret += "A"; + } else { + ret += std::to_string(curr->align); + } + return ret; +} + +static Name getStoreName(Store* curr) { + std::string ret = "SAFE_HEAP_STORE_"; + ret += curr->valueType.toString(); + ret += "_" + std::to_string(curr->bytes) + "_"; + if (curr->isAtomic) { + ret += "A"; + } else { + ret += std::to_string(curr->align); + } + return ret; +} + +struct AccessInstrumenter : public WalkerPass> { + // If the getSbrkPtr function is implemented in the wasm, we must not + // instrument that, as it would lead to infinite recursion of it calling + // SAFE_HEAP_LOAD that calls it and so forth. + Name getSbrkPtr; + + bool isFunctionParallel() override { return true; } + + AccessInstrumenter* create() override { + return new AccessInstrumenter(getSbrkPtr); + } + + AccessInstrumenter(Name getSbrkPtr) : getSbrkPtr(getSbrkPtr) {} + + void visitLoad(Load* curr) { + if (getFunction()->name == getSbrkPtr || curr->type == Type::unreachable) { + return; + } + Builder builder(*getModule()); + replaceCurrent( + builder.makeCall(getLoadName(curr), + {curr->ptr, builder.makeConstPtr(curr->offset.addr)}, + curr->type)); + } + + void visitStore(Store* curr) { + if (getFunction()->name == getSbrkPtr || curr->type == Type::unreachable) { + return; + } + Builder builder(*getModule()); + replaceCurrent(builder.makeCall( + getStoreName(curr), + {curr->ptr, builder.makeConstPtr(curr->offset.addr), curr->value}, + Type::none)); + } +}; + +struct SafeHeap : public Pass { + PassOptions options; + + void run(PassRunner* runner, Module* module) override { + options = runner->options; + // add imports + addImports(module); + // instrument loads and stores + AccessInstrumenter(getSbrkPtr).run(runner, module); + // add helper checking funcs and imports + addGlobals(module, module->features); + } + + Name dynamicTopPtr, getSbrkPtr, sbrk, segfault, alignfault; + + void addImports(Module* module) { + ImportInfo info(*module); + auto indexType = module->memory.indexType; + // Older emscripten imports env.DYNAMICTOP_PTR. + // Newer emscripten imports or exports emscripten_get_sbrk_ptr(). + if (auto* existing = info.getImportedGlobal(ENV, DYNAMICTOP_PTR_IMPORT)) { + dynamicTopPtr = existing->name; + } else if (auto* existing = info.getImportedFunction(ENV, GET_SBRK_PTR)) { + getSbrkPtr = existing->name; + } else if (auto* existing = module->getExportOrNull(GET_SBRK_PTR)) { + getSbrkPtr = existing->value; + } else if (auto* existing = info.getImportedFunction(ENV, SBRK)) { + sbrk = existing->name; + } else { + auto* import = new Function; + import->name = getSbrkPtr = GET_SBRK_PTR; + import->module = ENV; + import->base = GET_SBRK_PTR; + import->sig = Signature(Type::none, indexType); + module->addFunction(import); + } + if (auto* existing = info.getImportedFunction(ENV, SEGFAULT_IMPORT)) { + segfault = existing->name; + } else { + auto* import = new Function; + import->name = segfault = SEGFAULT_IMPORT; + import->module = ENV; + import->base = SEGFAULT_IMPORT; + import->sig = Signature(Type::none, Type::none); + module->addFunction(import); + } + if (auto* existing = info.getImportedFunction(ENV, ALIGNFAULT_IMPORT)) { + alignfault = existing->name; + } else { + auto* import = new Function; + import->name = alignfault = ALIGNFAULT_IMPORT; + import->module = ENV; + import->base = ALIGNFAULT_IMPORT; + import->sig = Signature(Type::none, Type::none); + module->addFunction(import); + } + } + + bool + isPossibleAtomicOperation(Index align, Index bytes, bool shared, Type type) { + return align == bytes && shared && type.isInteger(); + } + + void addGlobals(Module* module, FeatureSet features) { + // load funcs + Load load; + for (Type type : {Type::i32, Type::i64, Type::f32, Type::f64, Type::v128}) { + if (type == Type::v128 && !features.hasSIMD()) { + continue; + } + load.type = type; + for (Index bytes : {1, 2, 4, 8, 16}) { + load.bytes = bytes; + if (bytes > type.getByteSize() || (type == Type::f32 && bytes != 4) || + (type == Type::f64 && bytes != 8) || + (type == Type::v128 && bytes != 16)) { + continue; + } + for (auto signed_ : {true, false}) { + load.signed_ = signed_; + if (type.isFloat() && signed_) { + continue; + } + for (Index align : {1, 2, 4, 8, 16}) { + load.align = align; + if (align > bytes) { + continue; + } + for (auto isAtomic : {true, false}) { + load.isAtomic = isAtomic; + if (isAtomic && !isPossibleAtomicOperation( + align, bytes, module->memory.shared, type)) { + continue; + } + addLoadFunc(load, module); + } + } + } + } + } + // store funcs + Store store; + for (Type valueType : + {Type::i32, Type::i64, Type::f32, Type::f64, Type::v128}) { + if (valueType == Type::v128 && !features.hasSIMD()) { + continue; + } + store.valueType = valueType; + store.type = Type::none; + for (Index bytes : {1, 2, 4, 8, 16}) { + store.bytes = bytes; + if (bytes > valueType.getByteSize() || + (valueType == Type::f32 && bytes != 4) || + (valueType == Type::f64 && bytes != 8) || + (valueType == Type::v128 && bytes != 16)) { + continue; + } + for (Index align : {1, 2, 4, 8, 16}) { + store.align = align; + if (align > bytes) { + continue; + } + for (auto isAtomic : {true, false}) { + store.isAtomic = isAtomic; + if (isAtomic && !isPossibleAtomicOperation( + align, bytes, module->memory.shared, valueType)) { + continue; + } + addStoreFunc(store, module); + } + } + } + } + } + + // creates a function for a particular style of load + void addLoadFunc(Load style, Module* module) { + auto name = getLoadName(&style); + if (module->getFunctionOrNull(name)) { + return; + } + auto* func = new Function; + func->name = name; + // pointer, offset + auto indexType = module->memory.indexType; + func->sig = Signature({indexType, indexType}, style.type); + func->vars.push_back(indexType); // pointer + offset + Builder builder(*module); + auto* block = builder.makeBlock(); + block->list.push_back(builder.makeLocalSet( + 2, + builder.makeBinary(module->memory.is64() ? AddInt64 : AddInt32, + builder.makeLocalGet(0, indexType), + builder.makeLocalGet(1, indexType)))); + // check for reading past valid memory: if pointer + offset + bytes + block->list.push_back( + makeBoundsCheck(style.type, builder, 2, style.bytes, module)); + // check proper alignment + if (style.align > 1) { + block->list.push_back(makeAlignCheck(style.align, builder, 2, module)); + } + // do the load + auto* load = module->allocator.alloc(); + *load = style; // basically the same as the template we are given! + load->ptr = builder.makeLocalGet(2, indexType); + Expression* last = load; + if (load->isAtomic && load->signed_) { + // atomic loads cannot be signed, manually sign it + last = Bits::makeSignExt(load, load->bytes, *module); + load->signed_ = false; + } + block->list.push_back(last); + block->finalize(style.type); + func->body = block; + module->addFunction(func); + } + + // creates a function for a particular type of store + void addStoreFunc(Store style, Module* module) { + auto name = getStoreName(&style); + if (module->getFunctionOrNull(name)) { + return; + } + auto* func = new Function; + func->name = name; + // pointer, offset, value + auto indexType = module->memory.indexType; + func->sig = Signature({indexType, indexType, style.valueType}, Type::none); + func->vars.push_back(indexType); // pointer + offset + Builder builder(*module); + auto* block = builder.makeBlock(); + block->list.push_back(builder.makeLocalSet( + 3, + builder.makeBinary(module->memory.is64() ? AddInt64 : AddInt32, + builder.makeLocalGet(0, indexType), + builder.makeLocalGet(1, indexType)))); + // check for reading past valid memory: if pointer + offset + bytes + block->list.push_back( + makeBoundsCheck(style.valueType, builder, 3, style.bytes, module)); + // check proper alignment + if (style.align > 1) { + block->list.push_back(makeAlignCheck(style.align, builder, 3, module)); + } + // do the store + auto* store = module->allocator.alloc(); + *store = style; // basically the same as the template we are given! + store->ptr = builder.makeLocalGet(3, indexType); + store->value = builder.makeLocalGet(2, style.valueType); + block->list.push_back(store); + block->finalize(Type::none); + func->body = block; + module->addFunction(func); + } + + Expression* + makeAlignCheck(Address align, Builder& builder, Index local, Module* module) { + auto indexType = module->memory.indexType; + Expression* ptrBits = builder.makeLocalGet(local, indexType); + if (module->memory.is64()) { + ptrBits = builder.makeUnary(WrapInt64, ptrBits); + } + return builder.makeIf( + builder.makeBinary( + AndInt32, ptrBits, builder.makeConst(int32_t(align - 1))), + builder.makeCall(alignfault, {}, Type::none)); + } + + Expression* makeBoundsCheck( + Type type, Builder& builder, Index local, Index bytes, Module* module) { + auto indexType = module->memory.indexType; + auto upperOp = module->memory.is64() + ? options.lowMemoryUnused ? LtUInt64 : EqInt64 + : options.lowMemoryUnused ? LtUInt32 : EqInt32; + auto upperBound = options.lowMemoryUnused ? PassOptions::LowMemoryBound : 0; + Expression* brkLocation; + if (sbrk.is()) { + brkLocation = + builder.makeCall(sbrk, {builder.makeConstPtr(0)}, indexType); + } else { + Expression* sbrkPtr; + if (dynamicTopPtr.is()) { + sbrkPtr = builder.makeGlobalGet(dynamicTopPtr, indexType); + } else { + sbrkPtr = builder.makeCall(getSbrkPtr, {}, indexType); + } + auto size = module->memory.is64() ? 8 : 4; + brkLocation = builder.makeLoad(size, false, 0, size, sbrkPtr, indexType); + } + auto gtuOp = module->memory.is64() ? GtUInt64 : GtUInt32; + auto addOp = module->memory.is64() ? AddInt64 : AddInt32; + return builder.makeIf( + builder.makeBinary( + OrInt32, + builder.makeBinary(upperOp, + builder.makeLocalGet(local, indexType), + builder.makeConstPtr(upperBound)), + builder.makeBinary( + gtuOp, + builder.makeBinary(addOp, + builder.makeLocalGet(local, indexType), + builder.makeConstPtr(bytes)), + brkLocation)), + builder.makeCall(segfault, {}, Type::none)); + } +}; + +Pass* createSafeHeapPass() { return new SafeHeap(); } + +} // namespace wasm diff --git a/binaryen/src/passes/SimplifyGlobals.cpp b/binaryen/src/passes/SimplifyGlobals.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/passes/SimplifyGlobals.cpp @@ -0,0 +1,342 @@ +/* + * Copyright 2019 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// Simplify and optimize globals and their use. +// +// * Turns never-written and unwritable (not imported or exported) +// globals immutable. +// * If an immutable global is a copy of another, use the earlier one, +// to allow removal of the copies later. +// * Apply the constant values of immutable globals. +// * Apply the constant values of previous global.sets, in a linear +// execution trace. +// +// Some globals may not have uses after these changes, which we leave +// to other passes to optimize. +// +// This pass has a "optimize" variant (similar to inlining and DAE) +// that also runs general function optimizations where we managed to replace +// a constant value. That is helpful as such a replacement often opens up +// further optimization opportunities. +// + +#include + +#include "ir/effects.h" +#include "ir/properties.h" +#include "ir/utils.h" +#include "pass.h" +#include "wasm-builder.h" +#include "wasm.h" + +namespace wasm { + +namespace { + +struct GlobalInfo { + bool imported = false; + bool exported = false; + std::atomic written; + std::atomic read; +}; + +using GlobalInfoMap = std::map; + +struct GlobalUseScanner : public WalkerPass> { + bool isFunctionParallel() override { return true; } + + GlobalUseScanner(GlobalInfoMap* infos) : infos(infos) {} + + GlobalUseScanner* create() override { return new GlobalUseScanner(infos); } + + void visitGlobalSet(GlobalSet* curr) { (*infos)[curr->name].written = true; } + + void visitGlobalGet(GlobalGet* curr) { (*infos)[curr->name].read = true; } + +private: + GlobalInfoMap* infos; +}; + +using NameNameMap = std::map; +using NameSet = std::set; + +struct GlobalUseModifier : public WalkerPass> { + bool isFunctionParallel() override { return true; } + + GlobalUseModifier(NameNameMap* copiedParentMap) + : copiedParentMap(copiedParentMap) {} + + GlobalUseModifier* create() override { + return new GlobalUseModifier(copiedParentMap); + } + + void visitGlobalGet(GlobalGet* curr) { + auto iter = copiedParentMap->find(curr->name); + if (iter != copiedParentMap->end()) { + curr->name = iter->second; + } + } + +private: + NameNameMap* copiedParentMap; +}; + +struct ConstantGlobalApplier + : public WalkerPass< + LinearExecutionWalker>> { + bool isFunctionParallel() override { return true; } + + ConstantGlobalApplier(NameSet* constantGlobals, bool optimize) + : constantGlobals(constantGlobals), optimize(optimize) {} + + ConstantGlobalApplier* create() override { + return new ConstantGlobalApplier(constantGlobals, optimize); + } + + void visitExpression(Expression* curr) { + if (auto* set = curr->dynCast()) { + if (Properties::isConstantExpression(set->value)) { + currConstantGlobals[set->name] = + getLiteralsFromConstExpression(set->value); + } else { + currConstantGlobals.erase(set->name); + } + return; + } else if (auto* get = curr->dynCast()) { + // Check if the global is known to be constant all the time. + if (constantGlobals->count(get->name)) { + auto* global = getModule()->getGlobal(get->name); + assert(Properties::isConstantExpression(global->init)); + replaceCurrent(ExpressionManipulator::copy(global->init, *getModule())); + replaced = true; + return; + } + // Check if the global has a known value in this linear trace. + auto iter = currConstantGlobals.find(get->name); + if (iter != currConstantGlobals.end()) { + Builder builder(*getModule()); + replaceCurrent(builder.makeConstantExpression(iter->second)); + replaced = true; + } + return; + } + // Otherwise, invalidate if we need to. + EffectAnalyzer effects(getPassOptions(), getModule()->features); + effects.visit(curr); + assert(effects.globalsWritten.empty()); // handled above + if (effects.calls) { + currConstantGlobals.clear(); + } + } + + static void doNoteNonLinear(ConstantGlobalApplier* self, Expression** currp) { + self->currConstantGlobals.clear(); + } + + void visitFunction(Function* curr) { + if (replaced && optimize) { + PassRunner runner(getModule(), getPassRunner()->options); + runner.setIsNested(true); + runner.addDefaultFunctionOptimizationPasses(); + runner.runOnFunction(curr); + } + } + +private: + NameSet* constantGlobals; + bool optimize; + bool replaced = false; + + // The globals currently constant in the linear trace. + std::map currConstantGlobals; +}; + +struct GlobalSetRemover : public WalkerPass> { + GlobalSetRemover(const NameSet* toRemove, bool optimize) + : toRemove(toRemove), optimize(optimize) {} + + bool isFunctionParallel() override { return true; } + + GlobalSetRemover* create() override { + return new GlobalSetRemover(toRemove, optimize); + } + + void visitGlobalSet(GlobalSet* curr) { + if (toRemove->count(curr->name) != 0) { + replaceCurrent(Builder(*getModule()).makeDrop(curr->value)); + removed = true; + } + } + + void visitFunction(Function* curr) { + if (removed && optimize) { + PassRunner runner(getModule(), getPassRunner()->options); + runner.setIsNested(true); + runner.addDefaultFunctionOptimizationPasses(); + runner.runOnFunction(curr); + } + } + +private: + const NameSet* toRemove; + bool optimize; + bool removed = false; +}; + +} // anonymous namespace + +struct SimplifyGlobals : public Pass { + PassRunner* runner; + Module* module; + + GlobalInfoMap map; + bool optimize; + + SimplifyGlobals(bool optimize = false) : optimize(optimize) {} + + void run(PassRunner* runner_, Module* module_) override { + runner = runner_; + module = module_; + + analyze(); + + removeWritesToUnreadGlobals(); + + preferEarlierImports(); + + propagateConstantsToGlobals(); + + propagateConstantsToCode(); + } + + void analyze() { + // First, find out all the relevant info. + for (auto& global : module->globals) { + auto& info = map[global->name]; + if (global->imported()) { + info.imported = true; + } + } + for (auto& ex : module->exports) { + if (ex->kind == ExternalKind::Global) { + map[ex->value].exported = true; + } + } + GlobalUseScanner(&map).run(runner, module); + // We now know which are immutable in practice. + for (auto& global : module->globals) { + auto& info = map[global->name]; + if (global->mutable_ && !info.imported && !info.exported && + !info.written) { + global->mutable_ = false; + } + } + } + + void removeWritesToUnreadGlobals() { + // Globals that are not exports and not read from can be eliminated + // (even if they are written to). + NameSet unreadGlobals; + for (auto& global : module->globals) { + auto& info = map[global->name]; + if (!info.imported && !info.exported && !info.read) { + unreadGlobals.insert(global->name); + // We can now mark this global as immutable, and un-written, since we + // are about to remove all the `.set` operations on it. + global->mutable_ = false; + info.written = false; + } + } + GlobalSetRemover(&unreadGlobals, optimize).run(runner, module); + } + + void preferEarlierImports() { + // Optimize uses of immutable globals, prefer the earlier import when + // there is a copy. + NameNameMap copiedParentMap; + for (auto& global : module->globals) { + auto child = global->name; + if (!global->mutable_ && !global->imported()) { + if (auto* get = global->init->dynCast()) { + auto parent = get->name; + if (!module->getGlobal(get->name)->mutable_) { + copiedParentMap[child] = parent; + } + } + } + } + if (!copiedParentMap.empty()) { + // Go all the way back. + for (auto& global : module->globals) { + auto child = global->name; + if (copiedParentMap.count(child)) { + while (copiedParentMap.count(copiedParentMap[child])) { + copiedParentMap[child] = copiedParentMap[copiedParentMap[child]]; + } + } + } + // Apply to the gets. + GlobalUseModifier(&copiedParentMap).run(runner, module); + } + } + + // Constant propagation part 1: even an mutable global with a constant + // value can have that value propagated to another global that reads it, + // since we do know the value during startup, it can't be modified until + // code runs. + void propagateConstantsToGlobals() { + // Go over the list of globals in order, which is the order of + // initialization as well, tracking their constant values. + std::map constantGlobals; + for (auto& global : module->globals) { + if (!global->imported()) { + if (Properties::isConstantExpression(global->init)) { + constantGlobals[global->name] = + getLiteralsFromConstExpression(global->init); + } else if (auto* get = global->init->dynCast()) { + auto iter = constantGlobals.find(get->name); + if (iter != constantGlobals.end()) { + Builder builder(*module); + global->init = builder.makeConstantExpression(iter->second); + } + } + } + } + } + + // Constant propagation part 2: apply the values of immutable globals + // with constant values to to global.gets in the code. + void propagateConstantsToCode() { + NameSet constantGlobals; + for (auto& global : module->globals) { + if (!global->mutable_ && !global->imported() && + Properties::isConstantExpression(global->init)) { + constantGlobals.insert(global->name); + } + } + ConstantGlobalApplier(&constantGlobals, optimize).run(runner, module); + } +}; + +Pass* createSimplifyGlobalsPass() { return new SimplifyGlobals(false); } + +Pass* createSimplifyGlobalsOptimizingPass() { + return new SimplifyGlobals(true); +} + +} // namespace wasm diff --git a/binaryen/src/passes/SimplifyLocals.cpp b/binaryen/src/passes/SimplifyLocals.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/passes/SimplifyLocals.cpp @@ -0,0 +1,1055 @@ +/* + * Copyright 2015 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// Locals-related optimizations +// +// This "sinks" local.sets, pushing them to the next local.get where possible, +// and removing the set if there are no gets remaining (the latter is +// particularly useful in ssa mode, but not only). +// +// We also note where local.sets coalesce: if all breaks of a block set +// a specific local, we can use a block return value for it, in effect +// removing multiple local.sets and replacing them with one that the +// block returns to. Further optimization rounds then have the opportunity +// to remove that local.set as well. TODO: support partial traces; right +// now, whenever control flow splits, we invalidate everything. +// +// After this pass, some locals may be completely unused. reorder-locals +// can get rid of those (the operation is trivial there after it sorts by use +// frequency). +// +// This pass has options: +// +// * Tee: allow teeing, i.e., sinking a local with more than one use, +// and so after sinking we have a tee for the first use. +// * Structure: create block and if return values, by merging the +// internal local.sets into one on the outside, +// that can itself then be sunk further. +// +// There is also an option to disallow nesting entirely, which disallows +// Tee and Structure from those 2 options, and also disallows any sinking +// operation that would create nesting. This keeps the IR flat while +// removing redundant locals. +// + +#include "ir/equivalent_sets.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace wasm { + +// Main class + +template +struct SimplifyLocals + : public WalkerPass>> { + bool isFunctionParallel() override { return true; } + + Pass* create() override { + return new SimplifyLocals(); + } + + // information for a local.set we can sink + struct SinkableInfo { + Expression** item; + EffectAnalyzer effects; + + SinkableInfo(Expression** item, + PassOptions& passOptions, + FeatureSet features) + : item(item), effects(passOptions, features, *item) {} + }; + + // a list of sinkables in a linear execution trace + typedef std::map Sinkables; + + // locals in current linear execution trace, which we try to sink + Sinkables sinkables; + + // Information about an exit from a block: the break, and the + // sinkables. For the final exit from a block (falling off) + // exitter is null. + struct BlockBreak { + Expression** brp; + Sinkables sinkables; + }; + + // a list of all sinkable traces that exit a block. the last + // is falling off the end, others are branches. this is used for + // block returns + std::map> blockBreaks; + + // blocks that we can't produce a block return value for them. + // (switch target, or some other reason) + std::set unoptimizableBlocks; + + // A stack of sinkables from the current traversal state. When + // execution reaches an if-else, it splits, and can then + // be merged on return. + std::vector ifStack; + + // whether we need to run an additional cycle + bool anotherCycle; + + // whether this is the first cycle, in which we always disallow teeing + bool firstCycle; + + // local => # of local.gets for it + LocalGetCounter getCounter; + + static void + doNoteNonLinear(SimplifyLocals* self, + Expression** currp) { + // Main processing. + auto* curr = *currp; + if (auto* br = curr->dynCast()) { + if (br->value) { + // value means the block already has a return value + self->unoptimizableBlocks.insert(br->name); + } else { + self->blockBreaks[br->name].push_back( + {currp, std::move(self->sinkables)}); + } + } else if (curr->is()) { + return; // handled in visitBlock + } else if (curr->is()) { + assert(!curr->cast() + ->ifFalse); // if-elses are handled by doNoteIf* methods + } else if (curr->is()) { + auto* sw = curr->cast(); + auto targets = BranchUtils::getUniqueTargets(sw); + for (auto target : targets) { + self->unoptimizableBlocks.insert(target); + } + // TODO: we could use this info to stop gathering data on these blocks + } else if (auto* br = curr->dynCast()) { + // We cannot optimize the block this targets to have a return value, as + // the br_on_exn doesn't support a change to the block's type + self->unoptimizableBlocks.insert(br->name); + } + self->sinkables.clear(); + } + + static void doNoteIfCondition( + SimplifyLocals* self, + Expression** currp) { + // we processed the condition of this if-else, and now control flow branches + // into either the true or the false sides + self->sinkables.clear(); + } + + static void + doNoteIfTrue(SimplifyLocals* self, + Expression** currp) { + auto* iff = (*currp)->cast(); + if (iff->ifFalse) { + // We processed the ifTrue side of this if-else, save it on the stack. + self->ifStack.push_back(std::move(self->sinkables)); + } else { + // This is an if without an else. + if (allowStructure) { + self->optimizeIfReturn(iff, currp); + } + self->sinkables.clear(); + } + } + + static void + doNoteIfFalse(SimplifyLocals* self, + Expression** currp) { + // we processed the ifFalse side of this if-else, we can now try to + // mere with the ifTrue side and optimize a return value, if possible + auto* iff = (*currp)->cast(); + assert(iff->ifFalse); + if (allowStructure) { + self->optimizeIfElseReturn(iff, currp, self->ifStack.back()); + } + self->ifStack.pop_back(); + self->sinkables.clear(); + } + + void visitBlock(Block* curr) { + bool hasBreaks = curr->name.is() && blockBreaks[curr->name].size() > 0; + + if (allowStructure) { + optimizeBlockReturn(curr); // can modify blockBreaks + } + + // post-block cleanups + if (curr->name.is()) { + if (unoptimizableBlocks.count(curr->name)) { + sinkables.clear(); + unoptimizableBlocks.erase(curr->name); + } + + if (hasBreaks) { + // more than one path to here, so nonlinear + sinkables.clear(); + blockBreaks.erase(curr->name); + } + } + } + + void visitLoop(Loop* curr) { + if (allowStructure) { + optimizeLoopReturn(curr); + } + } + + void optimizeLocalGet(LocalGet* curr) { + auto found = sinkables.find(curr->index); + if (found != sinkables.end()) { + auto* set = (*found->second.item) + ->template cast(); // the set we may be sinking + bool oneUse = firstCycle || getCounter.num[curr->index] == 1; + // the set's value may be a get (i.e., the set is a copy) + auto* get = set->value->template dynCast(); + // if nesting is not allowed, and this might cause nesting, check if the + // sink would cause such a thing + if (!allowNesting) { + // a get is always ok to sink + if (!get) { + assert(expressionStack.size() >= 2); + assert(expressionStack[expressionStack.size() - 1] == curr); + auto* parent = expressionStack[expressionStack.size() - 2]; + bool parentIsSet = parent->template is(); + // if the parent of this get is a set, we can sink into the set's + // value, it would not be nested. + if (!parentIsSet) { + return; + } + } + } + // we can optimize here + if (!allowNesting && get && !oneUse) { + // if we can't nest 's a copy with multiple uses, then we can't create + // a tee, and we can't nop the origin, but we can at least switch to + // the copied index, which may make the origin unneeded eventually. + curr->index = get->index; + anotherCycle = true; + return; + } + // sink it, and nop the origin + if (oneUse) { + // with just one use, we can sink just the value + this->replaceCurrent(set->value); + } else { + this->replaceCurrent(set); + assert(!set->isTee()); + set->makeTee(this->getFunction()->getLocalType(set->index)); + } + // reuse the local.get that is dying + *found->second.item = curr; + ExpressionManipulator::nop(curr); + sinkables.erase(found); + anotherCycle = true; + } + } + + void visitDrop(Drop* curr) { + // collapse drop-tee into set, which can occur if a get was sunk into a tee + auto* set = curr->value->dynCast(); + if (set) { + assert(set->isTee()); + set->makeSet(); + this->replaceCurrent(set); + } + } + + void checkInvalidations(EffectAnalyzer& effects) { + // TODO: this is O(bad) + std::vector invalidated; + for (auto& sinkable : sinkables) { + if (effects.invalidates(sinkable.second.effects)) { + invalidated.push_back(sinkable.first); + } + } + for (auto index : invalidated) { + sinkables.erase(index); + } + } + + // a full expression stack is used when !allowNesting, so that we can check if + // a sink would cause nesting + ExpressionStack expressionStack; + + static void + visitPre(SimplifyLocals* self, + Expression** currp) { + Expression* curr = *currp; + + // Expressions that may throw cannot be sinked into 'try'. At the start of + // 'try', we drop all sinkables that may throw. + if (curr->is()) { + std::vector invalidated; + for (auto& sinkable : self->sinkables) { + if (sinkable.second.effects.throws) { + invalidated.push_back(sinkable.first); + } + } + for (auto index : invalidated) { + self->sinkables.erase(index); + } + } + + EffectAnalyzer effects(self->getPassOptions(), self->getModule()->features); + if (effects.checkPre(curr)) { + self->checkInvalidations(effects); + } + + if (!allowNesting) { + self->expressionStack.push_back(curr); + } + } + + static void + visitPost(SimplifyLocals* self, + Expression** currp) { + // Handling invalidations in the case where the current node is a get + // that we sink into is not trivial in general. In the simple case, + // all current sinkables are compatible with each other (otherwise one + // would have invalidated a previous one, and removed it). Given that, if + // we sink one of the sinkables, then that new code cannot invalidate any + // other sinkable - we've already compared them. However, a tricky case + // is when a sinkable contains another sinkable, + // + // (local.set $x + // (block (result i32) + // (A (local.get $y)) + // (local.set $y B) + // ) + // ) + // (C (local.get $y)) + // (D (local.get $x)) + // + // If we sink the set of $y, we have + // + // (local.set $x + // (block (result i32) + // (A (local.get $y)) + // (nop) + // ) + // ) + // (C B) + // (D (local.get $x)) + // + // There is now a risk that the set of $x should be invalidated, because + // if we sink it then A may happen after B (imagine that B contains + // something dangerous for that). To verify the risk, we could recursively + // scan all of B, but that is less efficient. Instead, the key thing is + // that if we sink out an inner part of a set, we should just leave further + // work on it to a later iteration. This is achieved by checking for + // invalidation on the original node, the local.get $y, which is guaranteed + // to invalidate the parent whose inner part was removed (since the inner + // part has a set, and the original node is a get of that same local). + // + // To implement this, if the current node is a get, note it and use it + // for invalidations later down. We must note it since optimizing the get + // may perform arbitrary changes to the graph, including reuse the get. + + Expression* original = *currp; + + LocalGet originalGet; + + if (auto* get = (*currp)->dynCast()) { + // Note: no visitor for LocalGet, so that we can handle it here. + originalGet = *get; + original = &originalGet; + self->optimizeLocalGet(get); + } + + // perform main LocalSet processing here, since we may be the result of + // replaceCurrent, i.e., no visitor for LocalSet, like LocalGet above. + auto* set = (*currp)->dynCast(); + + if (set) { + // if we see a set that was already potentially-sinkable, then the + // previous store is dead, leave just the value + auto found = self->sinkables.find(set->index); + if (found != self->sinkables.end()) { + auto* previous = (*found->second.item)->template cast(); + assert(!previous->isTee()); + auto* previousValue = previous->value; + Drop* drop = ExpressionManipulator::convert(previous); + drop->value = previousValue; + drop->finalize(); + self->sinkables.erase(found); + self->anotherCycle = true; + } + } + + FeatureSet features = self->getModule()->features; + EffectAnalyzer effects(self->getPassOptions(), features); + if (effects.checkPost(original)) { + self->checkInvalidations(effects); + } + + if (set && self->canSink(set)) { + Index index = set->index; + assert(self->sinkables.count(index) == 0); + self->sinkables.emplace(std::make_pair( + index, SinkableInfo(currp, self->getPassOptions(), features))); + } + + if (!allowNesting) { + self->expressionStack.pop_back(); + } + } + + bool canSink(LocalSet* set) { + // we can never move a tee + if (set->isTee()) { + return false; + } + // We cannot move expressions containing exnref.pops that are not enclosed + // in 'catch', because 'exnref.pop' should follow right after 'catch'. + FeatureSet features = this->getModule()->features; + if (features.hasExceptionHandling() && + EffectAnalyzer(this->getPassOptions(), features, set->value) + .danglingPop) { + return false; + } + // if in the first cycle, or not allowing tees, then we cannot sink if >1 + // use as that would make a tee + if ((firstCycle || !allowTee) && getCounter.num[set->index] > 1) { + return false; + } + return true; + } + + std::vector blocksToEnlarge; + std::vector ifsToEnlarge; + std::vector loopsToEnlarge; + + void optimizeLoopReturn(Loop* loop) { + // If there is a sinkable thing in an eligible loop, we can optimize + // it in a trivial way to the outside of the loop. + if (loop->type != Type::none) { + return; + } + if (sinkables.empty()) { + return; + } + Index goodIndex = sinkables.begin()->first; + // Ensure we have a place to write the return values for, if not, we + // need another cycle. + auto* block = loop->body->dynCast(); + if (!block || block->name.is() || block->list.size() == 0 || + !block->list.back()->is()) { + loopsToEnlarge.push_back(loop); + return; + } + Builder builder(*this->getModule()); + auto** item = sinkables.at(goodIndex).item; + auto* set = (*item)->template cast(); + block->list[block->list.size() - 1] = set->value; + *item = builder.makeNop(); + block->finalize(); + assert(block->type != Type::none); + loop->finalize(); + set->value = loop; + set->finalize(); + this->replaceCurrent(set); + // We moved things around, clear all tracking; we'll do another cycle + // anyhow. + sinkables.clear(); + anotherCycle = true; + } + + void optimizeBlockReturn(Block* block) { + if (!block->name.is() || unoptimizableBlocks.count(block->name) > 0) { + return; + } + auto breaks = std::move(blockBreaks[block->name]); + blockBreaks.erase(block->name); + if (breaks.size() == 0) { + // block has no branches TODO we might optimize trivial stuff here too + return; + } + // block does not already have a return value (if one break has one, they + // all do) + assert(!(*breaks[0].brp)->template cast()->value); + // look for a local.set that is present in them all + bool found = false; + Index sharedIndex = -1; + for (auto& sinkable : sinkables) { + Index index = sinkable.first; + bool inAll = true; + for (size_t j = 0; j < breaks.size(); j++) { + if (breaks[j].sinkables.count(index) == 0) { + inAll = false; + break; + } + } + if (inAll) { + sharedIndex = index; + found = true; + break; + } + } + if (!found) { + return; + } + // If one of our brs is a br_if, then we will give it a value. since + // the value executes before the condition, it is dangerous if we are + // moving code out of the condition, + // (br_if + // (block + // ..use $x.. + // (local.set $x ..) + // ) + // ) + // => + // (br_if + // (local.tee $x ..) ;; this now affects the use! + // (block + // ..use $x.. + // ) + // ) + // so we must check for that. + FeatureSet features = this->getModule()->features; + for (size_t j = 0; j < breaks.size(); j++) { + // move break local.set's value to the break + auto* breakLocalSetPointer = breaks[j].sinkables.at(sharedIndex).item; + auto* brp = breaks[j].brp; + auto* br = (*brp)->template cast(); + auto* set = (*breakLocalSetPointer)->template cast(); + if (br->condition) { + // TODO: optimize + FindAll findAll(br->condition); + for (auto* otherSet : findAll.list) { + if (otherSet == set) { + // the set is indeed in the condition, so we can't just move it + // but maybe there are no effects? see if, ignoring the set + // itself, there is any risk + Nop nop; + *breakLocalSetPointer = &nop; + EffectAnalyzer condition( + this->getPassOptions(), features, br->condition); + EffectAnalyzer value(this->getPassOptions(), features, set); + *breakLocalSetPointer = set; + if (condition.invalidates(value)) { + // indeed, we can't do this, stop + return; + } + break; // we found set in the list, can stop now + } + } + } + } + // Great, this local is set in them all, we can optimize! + if (block->list.size() == 0 || !block->list.back()->is()) { + // We can't do this here, since we can't push to the block - + // it would invalidate sinkable pointers. So we queue a request + // to grow the block at the end of the turn, we'll get this next + // cycle. + blocksToEnlarge.push_back(block); + return; + } + // move block local.set's value to the end, in return position, and nop the + // set + auto* blockLocalSetPointer = sinkables.at(sharedIndex).item; + auto* value = (*blockLocalSetPointer)->template cast()->value; + block->list[block->list.size() - 1] = value; + ExpressionManipulator::nop(*blockLocalSetPointer); + for (size_t j = 0; j < breaks.size(); j++) { + // move break local.set's value to the break + auto* breakLocalSetPointer = breaks[j].sinkables.at(sharedIndex).item; + auto* brp = breaks[j].brp; + auto* br = (*brp)->template cast(); + assert(!br->value); + // if the break is conditional, then we must set the value here - if the + // break is not reached, we must still have the new value in the local + auto* set = (*breakLocalSetPointer)->template cast(); + if (br->condition) { + br->value = set; + set->makeTee(this->getFunction()->getLocalType(set->index)); + *breakLocalSetPointer = + this->getModule()->allocator.template alloc(); + // in addition, as this is a conditional br that now has a value, it now + // returns a value, so it must be dropped + br->finalize(); + *brp = Builder(*this->getModule()).makeDrop(br); + } else { + br->value = set->value; + ExpressionManipulator::nop(set); + } + } + // finally, create a local.set on the block itself + auto* newLocalSet = + Builder(*this->getModule()).makeLocalSet(sharedIndex, block); + this->replaceCurrent(newLocalSet); + sinkables.clear(); + anotherCycle = true; + block->finalize(); + } + + // optimize local.sets from both sides of an if into a return value + void optimizeIfElseReturn(If* iff, Expression** currp, Sinkables& ifTrue) { + assert(iff->ifFalse); + // if this if already has a result, or is unreachable code, we have + // nothing to do + if (iff->type != Type::none) { + return; + } + // We now have the sinkables from both sides of the if, and can look + // for something to sink. That is either a shared index on both sides, + // *or* if one side is unreachable, we can sink anything from the other, + // (if + // (..) + // (br $x) + // (local.set $y (..)) + // ) + // => + // (local.set $y + // (if (result i32) + // (..) + // (br $x) + // (..) + // ) + // ) + Sinkables& ifFalse = sinkables; + Index goodIndex = -1; + bool found = false; + if (iff->ifTrue->type == Type::unreachable) { + // since the if type is none + assert(iff->ifFalse->type != Type::unreachable); + if (!ifFalse.empty()) { + goodIndex = ifFalse.begin()->first; + found = true; + } + } else if (iff->ifFalse->type == Type::unreachable) { + // since the if type is none + assert(iff->ifTrue->type != Type::unreachable); + if (!ifTrue.empty()) { + goodIndex = ifTrue.begin()->first; + found = true; + } + } else { + // Look for a shared index. + for (auto& sinkable : ifTrue) { + Index index = sinkable.first; + if (ifFalse.count(index) > 0) { + goodIndex = index; + found = true; + break; + } + } + } + if (!found) { + return; + } + // great, we can optimize! + // ensure we have a place to write the return values for, if not, we + // need another cycle + auto* ifTrueBlock = iff->ifTrue->dynCast(); + if (iff->ifTrue->type != Type::unreachable) { + if (!ifTrueBlock || ifTrueBlock->name.is() || + ifTrueBlock->list.size() == 0 || + !ifTrueBlock->list.back()->is()) { + ifsToEnlarge.push_back(iff); + return; + } + } + auto* ifFalseBlock = iff->ifFalse->dynCast(); + if (iff->ifFalse->type != Type::unreachable) { + if (!ifFalseBlock || ifFalseBlock->name.is() || + ifFalseBlock->list.size() == 0 || + !ifFalseBlock->list.back()->is()) { + ifsToEnlarge.push_back(iff); + return; + } + } + // all set, go + if (iff->ifTrue->type != Type::unreachable) { + auto* ifTrueItem = ifTrue.at(goodIndex).item; + ifTrueBlock->list[ifTrueBlock->list.size() - 1] = + (*ifTrueItem)->template cast()->value; + ExpressionManipulator::nop(*ifTrueItem); + ifTrueBlock->finalize(); + assert(ifTrueBlock->type != Type::none); + } + if (iff->ifFalse->type != Type::unreachable) { + auto* ifFalseItem = ifFalse.at(goodIndex).item; + ifFalseBlock->list[ifFalseBlock->list.size() - 1] = + (*ifFalseItem)->template cast()->value; + ExpressionManipulator::nop(*ifFalseItem); + ifFalseBlock->finalize(); + assert(ifFalseBlock->type != Type::none); + } + iff->finalize(); // update type + assert(iff->type != Type::none); + // finally, create a local.set on the iff itself + auto* newLocalSet = + Builder(*this->getModule()).makeLocalSet(goodIndex, iff); + *currp = newLocalSet; + anotherCycle = true; + } + + // Optimize local.sets from a one-sided iff, adding a get on the other: + // (if + // (..condition..) + // (block + // (local.set $x (..value..)) + // ) + // ) + // => + // (local.set $x + // (if (result ..) + // (..condition..) + // (block (result ..) + // (..value..) + // ) + // (local.get $x) + // ) + // ) + // This is a speculative optimization: we add a get here, as well as a branch + // in the if, so this is harmful for code size and for speed. However, later + // optimizations may sink the set and enable other useful things. If none of + // that happens, other passes can "undo" this by turning an if with a copy + // arm into a one-sided if. + void optimizeIfReturn(If* iff, Expression** currp) { + // If this if is unreachable code, we have nothing to do. + if (iff->type != Type::none || iff->ifTrue->type != Type::none) { + return; + } + // Anything sinkable is good for us. + if (sinkables.empty()) { + return; + } + Index goodIndex = sinkables.begin()->first; + // Ensure we have a place to write the return values for, if not, we + // need another cycle. + auto* ifTrueBlock = iff->ifTrue->dynCast(); + if (!ifTrueBlock || ifTrueBlock->name.is() || + ifTrueBlock->list.size() == 0 || !ifTrueBlock->list.back()->is()) { + ifsToEnlarge.push_back(iff); + return; + } + // Update the ifTrue side. + Builder builder(*this->getModule()); + auto** item = sinkables.at(goodIndex).item; + auto* set = (*item)->template cast(); + ifTrueBlock->list[ifTrueBlock->list.size() - 1] = set->value; + *item = builder.makeNop(); + ifTrueBlock->finalize(); + assert(ifTrueBlock->type != Type::none); + // Update the ifFalse side. + iff->ifFalse = builder.makeLocalGet( + set->index, this->getFunction()->getLocalType(set->index)); + iff->finalize(); // update type + // Update the get count. + getCounter.num[set->index]++; + assert(iff->type != Type::none); + // Finally, reuse the local.set on the iff itself. + set->value = iff; + set->finalize(); + *currp = set; + anotherCycle = true; + } + + // override scan to add a pre and a post check task to all nodes + static void scan(SimplifyLocals* self, + Expression** currp) { + self->pushTask(visitPost, currp); + + auto* curr = *currp; + + if (auto* iff = curr->dynCast()) { + // handle if in a special manner, using the ifStack for if-elses etc. + if (iff->ifFalse) { + self->pushTask( + SimplifyLocals::doNoteIfFalse, + currp); + self->pushTask( + SimplifyLocals::scan, + &iff->ifFalse); + } + self->pushTask( + SimplifyLocals::doNoteIfTrue, + currp); + self->pushTask( + SimplifyLocals::scan, + &iff->ifTrue); + self->pushTask(SimplifyLocals:: + doNoteIfCondition, + currp); + self->pushTask( + SimplifyLocals::scan, + &iff->condition); + } else { + WalkerPass>>::scan(self, + currp); + } + + self->pushTask(visitPre, currp); + } + + void doWalkFunction(Function* func) { + if (func->getNumLocals() == 0) { + return; // nothing to do + } + // scan local.gets + getCounter.analyze(func); + // multiple passes may be required per function, consider this: + // x = load + // y = store + // c(x, y) + // the load cannot cross the store, but y can be sunk, after which so can x. + // + // we start with a cycle focusing on single-use locals, which are easy to + // sink (we don't need to put a set), and a good match for common compiler + // output patterns. further cycles do fully general sinking. + firstCycle = true; + do { + anotherCycle = runMainOptimizations(func); + // After the special first cycle, definitely do another. + if (firstCycle) { + firstCycle = false; + anotherCycle = true; + } + // If we are all done, run the final optimizations, which may suggest we + // can do more work. + if (!anotherCycle) { + // Don't run multiple cycles of just the final optimizations - in + // particular, get canonicalization is not guaranteed to converge. + // Instead, if final opts help then see if they enable main + // opts; continue only if they do. In other words, do not end up + // doing final opts again and again when no main opts are being + // enabled. + if (runLateOptimizations(func) && runMainOptimizations(func)) { + anotherCycle = true; + } + } + } while (anotherCycle); + } + + bool runMainOptimizations(Function* func) { + anotherCycle = false; + WalkerPass>>:: + doWalkFunction(func); + // enlarge blocks that were marked, for the next round + if (blocksToEnlarge.size() > 0) { + for (auto* block : blocksToEnlarge) { + block->list.push_back( + this->getModule()->allocator.template alloc()); + } + blocksToEnlarge.clear(); + anotherCycle = true; + } + // enlarge ifs that were marked, for the next round + if (ifsToEnlarge.size() > 0) { + for (auto* iff : ifsToEnlarge) { + auto ifTrue = + Builder(*this->getModule()).blockifyWithName(iff->ifTrue, Name()); + iff->ifTrue = ifTrue; + if (ifTrue->list.size() == 0 || + !ifTrue->list.back()->template is()) { + ifTrue->list.push_back( + this->getModule()->allocator.template alloc()); + } + if (iff->ifFalse) { + auto ifFalse = + Builder(*this->getModule()).blockifyWithName(iff->ifFalse, Name()); + iff->ifFalse = ifFalse; + if (ifFalse->list.size() == 0 || + !ifFalse->list.back()->template is()) { + ifFalse->list.push_back( + this->getModule()->allocator.template alloc()); + } + } + } + ifsToEnlarge.clear(); + anotherCycle = true; + } + // enlarge loops that were marked, for the next round + if (loopsToEnlarge.size() > 0) { + for (auto* loop : loopsToEnlarge) { + auto block = + Builder(*this->getModule()).blockifyWithName(loop->body, Name()); + loop->body = block; + if (block->list.size() == 0 || + !block->list.back()->template is()) { + block->list.push_back( + this->getModule()->allocator.template alloc()); + } + } + loopsToEnlarge.clear(); + anotherCycle = true; + } + // clean up + sinkables.clear(); + blockBreaks.clear(); + unoptimizableBlocks.clear(); + return anotherCycle; + } + + bool runLateOptimizations(Function* func) { + // Finally, after optimizing a function we can do some additional + // optimization. + getCounter.analyze(func); + // Remove equivalent copies - assignment of + // a local to another local that already contains that value. Note that + // we do that at the very end, and only after structure, as removing + // the copy here: + // (if + // (local.get $var$0) + // (local.set $var$0 + // (local.get $var$0) + // ) + // (local.set $var$0 + // (i32.const 208) + // ) + // ) + // will inhibit us creating an if return value. + struct EquivalentOptimizer + : public LinearExecutionWalker { + std::vector* numLocalGets; + bool removeEquivalentSets; + Module* module; + + bool anotherCycle = false; + + // We track locals containing the same value. + EquivalentSets equivalences; + + static void doNoteNonLinear(EquivalentOptimizer* self, + Expression** currp) { + // TODO do this across non-linear paths too, in coalesce-locals perhaps? + // (would inhibit structure opts here, though. + self->equivalences.clear(); + } + + void visitLocalSet(LocalSet* curr) { + // Remove trivial copies, even through a tee + auto* value = curr->value; + Function* func = this->getFunction(); + while (auto* subSet = value->dynCast()) { + value = subSet->value; + } + if (auto* get = value->dynCast()) { + if (equivalences.check(curr->index, get->index)) { + // This is an unnecessary copy! + if (removeEquivalentSets) { + if (curr->isTee()) { + this->replaceCurrent(curr->value); + } else { + this->replaceCurrent(Builder(*module).makeDrop(curr->value)); + } + anotherCycle = true; + } + } else if (func->getLocalType(curr->index) == + func->getLocalType(get->index)) { + // There is a new equivalence now. + equivalences.reset(curr->index); + equivalences.add(curr->index, get->index); + } + } else { + // A new value is assigned here. + equivalences.reset(curr->index); + } + } + + void visitLocalGet(LocalGet* curr) { + // Canonicalize gets: if some are equivalent, then we can pick more + // then one, and other passes may benefit from having more uniformity. + if (auto* set = equivalences.getEquivalents(curr->index)) { + // Pick the index with the most uses - maximizing the chance to + // lower one's uses to zero. + // Helper method that returns the # of gets *ignoring the current + // get*, as we want to see what is best overall, treating this one as + // to be decided upon. + auto getNumGetsIgnoringCurr = [&](Index index) { + auto ret = (*numLocalGets)[index]; + if (index == curr->index) { + assert(ret >= 1); + ret--; + } + return ret; + }; + Index best = -1; + for (auto index : *set) { + if (best == Index(-1) || + getNumGetsIgnoringCurr(index) > getNumGetsIgnoringCurr(best)) { + best = index; + } + } + assert(best != Index(-1)); + // Due to ordering, the best index may be different from us but have + // the same # of locals - make sure we actually improve. + if (best != curr->index && getNumGetsIgnoringCurr(best) > + getNumGetsIgnoringCurr(curr->index)) { + // Update the get counts. + (*numLocalGets)[best]++; + assert((*numLocalGets)[curr->index] >= 1); + (*numLocalGets)[curr->index]--; + // Make the change. + curr->index = best; + anotherCycle = true; + } + } + } + }; + + EquivalentOptimizer eqOpter; + eqOpter.module = this->getModule(); + eqOpter.numLocalGets = &getCounter.num; + eqOpter.removeEquivalentSets = allowStructure; + eqOpter.walkFunction(func); + + // We may have already had a local with no uses, or we may have just + // gotten there thanks to the EquivalentOptimizer. If there are such + // locals, remove all their sets. + UnneededSetRemover setRemover( + getCounter, func, this->getPassOptions(), this->getModule()->features); + setRemover.setModule(this->getModule()); + + return eqOpter.anotherCycle || setRemover.removed; + } +}; + +Pass* createSimplifyLocalsPass() { return new SimplifyLocals(); } + +Pass* createSimplifyLocalsNoTeePass() { + return new SimplifyLocals(); +} + +Pass* createSimplifyLocalsNoStructurePass() { + return new SimplifyLocals(); +} + +Pass* createSimplifyLocalsNoTeeNoStructurePass() { + return new SimplifyLocals(); +} + +Pass* createSimplifyLocalsNoNestingPass() { + return new SimplifyLocals(); +} + +} // namespace wasm diff --git a/binaryen/src/passes/Souperify.cpp b/binaryen/src/passes/Souperify.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/passes/Souperify.cpp @@ -0,0 +1,764 @@ +/* + * Copyright 2018 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// Souperify - convert to Souper IR in text form. +// +// This needs 'flatten' to be run before it, as it assumes the IR is in +// flat form. You may also want to optimize a little, e.g. +// --flatten --simplify-locals-nonesting --reorder-locals +// (as otherwise flattening introduces many copies; we do ignore boring +// copies here, but they end up as identical LHSes). +// +// See https://github.com/google/souper/issues/323 +// +// TODO: +// * pcs and blockpcs for things other than ifs +// * Investigate 'inlining', adding in nodes through calls +// * Consider generalizing DataFlow IR for internal Binaryen use. +// * Automatic conversion of Binaryen IR opts to run on the DataFlow IR. +// This would subsume precompute-propagate, for example. Using DFIR we +// can "expand" the BIR into expressions that BIR opts can handle +// directly, without the need for *-propagate techniques. +// + +#include "dataflow/graph.h" +#include "dataflow/node.h" +#include "dataflow/utils.h" +#include "ir/flat.h" +#include "ir/local-graph.h" +#include "ir/utils.h" +#include "pass.h" +#include "wasm-builder.h" +#include "wasm.h" + +namespace wasm { + +static int debug() { + static char* str = getenv("BINARYEN_DEBUG_SOUPERIFY"); + static int ret = str ? atoi(str) : 0; + return ret; +} + +namespace DataFlow { + +// Internal helper to find all the uses of a set. +struct UseFinder { + // Gets a list of all the uses of an expression. As we are in flat IR, + // the expression must be the value of a set, and we seek the other sets + // (or rather, their values) that contain a get that uses that value. + // There may also be non-set uses of the value, for example in a drop + // or a return. We represent those with a nullptr, meaning "other". + std::vector + getUses(Expression* origin, Graph& graph, LocalGraph& localGraph) { + if (debug() >= 2) { + std::cout << "getUses\n" << origin << '\n'; + } + std::vector ret; + auto* set = graph.getSet(origin); + if (!set) { + // If the parent is not a set (a drop, call, return, etc.) then + // it is not something we need to track. + return ret; + } + addSetUses(set, graph, localGraph, ret); + return ret; + } + + // There may be loops of sets with copies between them. + std::unordered_set seenSets; + + void addSetUses(LocalSet* set, + Graph& graph, + LocalGraph& localGraph, + std::vector& ret) { + // If already handled, nothing to do here. + if (seenSets.count(set)) { + return; + } + seenSets.insert(set); + // Find all the uses of that set. + auto& gets = localGraph.setInfluences[set]; + if (debug() >= 2) { + std::cout << "addSetUses for " << set << ", " << gets.size() << " gets\n"; + } + for (auto* get : gets) { + // Each of these relevant gets is either + // (1) a child of a set, which we can track, or + // (2) not a child of a set, e.g., a call argument or such + auto& sets = localGraph.getInfluences[get]; // TODO: iterator + // In flat IR, each get can influence at most 1 set. + assert(sets.size() <= 1); + if (sets.size() == 0) { + // This get is not the child of a set. Check if it is a drop, + // otherwise it is an actual use, and so an external use. + auto* parent = graph.getParent(get); + if (parent && parent->is()) { + // Just ignore it. + } else { + ret.push_back(nullptr); + if (debug() >= 2) { + std::cout << "add nullptr\n"; + } + } + } else { + // This get is the child of a set. + auto* subSet = *sets.begin(); + // If this is a copy, we need to look through it: data-flow IR + // counts actual values, not copies, and in particular we need + // to look through the copies that implement a phi. + if (subSet->value == get) { + // Indeed a copy. + // TODO: this could be optimized and done all at once beforehand. + addSetUses(subSet, graph, localGraph, ret); + } else { + // Not a copy. + auto* value = subSet->value; + ret.push_back(value); + if (debug() >= 2) { + std::cout << "add a value\n" << value << '\n'; + } + } + } + } + } +}; + +// Generates a trace: all the information to generate a Souper LHS +// for a specific local.set whose value we want to infer. +struct Trace { + Graph& graph; + Node* toInfer; + // Nodes we should exclude from being children of traces (but they + // may be the root we try to infer. + std::unordered_set& excludeAsChildren; + + // A limit on how deep we go - we don't want to create arbitrarily + // large traces. + size_t depthLimit = 10; + size_t totalLimit = 30; + + bool bad = false; + std::vector nodes; + std::unordered_set addedNodes; + std::vector pathConditions; + // When we need to (like when the depth is too deep), we replace + // expressions with other expressions, and track them here. + std::unordered_map> replacements; + // The nodes that have additional external uses (only computed + // for the "work" nodes, not the descriptive nodes arriving for + // path conditions). + std::unordered_set hasExternalUses; + // We add path conditions after the "work". We collect them here + // and then go through them at the proper time. + std::vector conditionsToAdd; + // Whether we are at the adding-conditions stage (i.e., post + // adding the "work"). + bool addingConditions = false; + // The local information graph. Used to check if a node has external uses. + LocalGraph& localGraph; + + Trace(Graph& graph, + Node* toInfer, + std::unordered_set& excludeAsChildren, + LocalGraph& localGraph) + : graph(graph), toInfer(toInfer), excludeAsChildren(excludeAsChildren), + localGraph(localGraph) { + if (debug() >= 2) { + std::cout << "\nstart a trace (in " << graph.func->name << ")\n"; + } + // Check if there is a depth limit override + auto* depthLimitStr = getenv("BINARYEN_SOUPERIFY_DEPTH_LIMIT"); + if (depthLimitStr) { + depthLimit = atoi(depthLimitStr); + } + auto* totalLimitStr = getenv("BINARYEN_SOUPERIFY_TOTAL_LIMIT"); + if (totalLimitStr) { + totalLimit = atoi(totalLimitStr); + } + // Pull in all the dependencies, starting from the value itself. + add(toInfer, 0); + if (bad) { + return; + } + // If we are trivial before adding pcs, we are still trivial, and + // can ignore this. + auto sizeBeforePathConditions = nodes.size(); + // No input is uninteresting + if (sizeBeforePathConditions == 0) { + bad = true; + return; + } + // Just a var is uninteresting. TODO: others too? + if (sizeBeforePathConditions == 1 && nodes[0]->isVar()) { + bad = true; + return; + } + // Before adding the path conditions, we can now compute the + // actual number of uses of "work" nodes, the real computation done + // here and that we hope to replace, as opposed to path condition + // computation which is only descriptive and helps optimization of + // the work. + findExternalUses(); + // We can now add conditions. + addingConditions = true; + for (auto* condition : conditionsToAdd) { + add(condition, 0); + } + // Add in path conditions based on the location of this node: e.g. + // if it is inside an if's true branch, we can add a path-condition + // for that. + auto iter = graph.nodeParentMap.find(toInfer); + if (iter != graph.nodeParentMap.end()) { + addPath(toInfer, iter->second); + } + } + + Node* add(Node* node, size_t depth) { + depth++; + // If replaced, return the replacement. + auto iter = replacements.find(node); + if (iter != replacements.end()) { + return iter->second.get(); + } + // If already added, nothing more to do. + if (addedNodes.find(node) != addedNodes.end()) { + return node; + } + switch (node->type) { + case Node::Type::Var: { + break; // nothing more to add + } + case Node::Type::Expr: { + // If this is a Const, it's not an instruction - nothing to add, + // it's just a value. + if (node->expr->is()) { + return node; + } + // If we've gone too deep, emit a var instead. + // Do the same if this is a node we should exclude from traces. + if (depth >= depthLimit || nodes.size() >= totalLimit || + (node != toInfer && + excludeAsChildren.find(node) != excludeAsChildren.end())) { + auto type = node->getWasmType(); + assert(type.isConcrete()); + auto* var = Node::makeVar(type); + replacements[node] = std::unique_ptr(var); + node = var; + break; + } + // Add the dependencies. + assert(!node->expr->is()); + for (Index i = 0; i < node->values.size(); i++) { + add(node->getValue(i), depth); + } + break; + } + case Node::Type::Phi: { + auto* block = add(node->getValue(0), depth); + assert(block); + auto size = block->values.size(); + // First, add the conditions for the block + for (Index i = 0; i < size; i++) { + // a condition may be bad, but conditions are not necessary - + // we can proceed without the extra condition information + auto* condition = block->getValue(i); + if (!condition->isBad()) { + if (!addingConditions) { + // Too early, queue it for later. + conditionsToAdd.push_back(condition); + } else { + add(condition, depth); + } + } + } + // Then, add the phi values + for (Index i = 1; i < size + 1; i++) { + add(node->getValue(i), depth); + } + break; + } + case Node::Type::Cond: { + add(node->getValue(0), depth); // add the block + add(node->getValue(1), depth); // add the node + break; + } + case Node::Type::Block: { + break; // nothing more to add + } + case Node::Type::Zext: { + add(node->getValue(0), depth); + break; + } + case Node::Type::Bad: { + bad = true; + return nullptr; + } + default: + WASM_UNREACHABLE("unexpected node type"); + } + // Assert on no cycles + assert(addedNodes.find(node) == addedNodes.end()); + nodes.push_back(node); + addedNodes.insert(node); + return node; + } + + void addPath(Node* node, Expression* curr) { + // We track curr and parent, which are always in the state of parent + // being the parent of curr. + auto* parent = graph.expressionParentMap.at(curr); + while (parent) { + auto iter = graph.expressionConditionMap.find(parent); + if (iter != graph.expressionConditionMap.end()) { + // Given the block, add a proper path-condition + addPathTo(parent, curr, iter->second); + } + curr = parent; + parent = graph.expressionParentMap.at(parent); + } + } + + // curr is a child of parent, and parent has a Block which we are + // give as 'node'. Add a path condition for reaching the child. + void addPathTo(Expression* parent, + Expression* curr, + std::vector conditions) { + if (auto* iff = parent->dynCast()) { + Index index; + if (curr == iff->ifTrue) { + index = 0; + } else if (curr == iff->ifFalse) { + index = 1; + } else { + WASM_UNREACHABLE("invalid expr"); + } + auto* condition = conditions[index]; + // Add the condition itself as an instruction in the trace - + // the pc uses it as its input. + add(condition, 0); + // Add it as a pc, which we will emit directly. + pathConditions.push_back(condition); + } else { + WASM_UNREACHABLE("invalid expr"); + } + } + + bool isBad() { return bad; } + + static bool isTraceable(Node* node) { + if (!node->origin) { + // Ignore artificial etc. nodes. + // TODO: perhaps require all the nodes for an origin appear, so we + // don't try to compute an internal part of one, like the + // extra artificial != 0 of a select? + return false; + } + if (node->isExpr()) { + // Consider only the simple computational nodes. + auto* expr = node->expr; + return expr->is() || expr->is() || expr->is()) { + std::cout << "select "; + printInternal(node->getValue(0)); + std::cout << ", "; + printInternal(node->getValue(1)); + std::cout << ", "; + printInternal(node->getValue(2)); + } else { + WASM_UNREACHABLE("unexecpted node type"); + } + } + + void printPathCondition(Node* condition) { + std::cout << "pc "; + printInternal(condition); + std::cout << " 1:i1\n"; + } + + // Checks if a value looks suspiciously optimizable. + void warnOnSuspiciousValues(Node* node) { + assert(debug()); + // If the node has no uses, it's not interesting enough to be + // suspicious. TODO + // If an input was replaced with a var, then we should not + // look into it, it's not suspiciously trivial. + for (auto* value : node->values) { + if (value != getMaybeReplaced(value)) { + return; + } + } + if (allInputsIdentical(node)) { + std::cout << "^^ suspicious identical inputs! missing optimization in " + << graph.func->name << "? ^^\n"; + return; + } + if (!node->isPhi() && allInputsConstant(node)) { + std::cout << "^^ suspicious constant inputs! missing optimization in " + << graph.func->name << "? ^^\n"; + return; + } + } +}; + +} // namespace DataFlow + +struct Souperify : public WalkerPass> { + // Not parallel, for now - could parallelize and combine outputs at the end. + // If Souper is thread-safe, we could also run it in parallel. + + bool singleUseOnly; + + Souperify(bool singleUseOnly) : singleUseOnly(singleUseOnly) {} + + void doWalkFunction(Function* func) { + std::cout << "\n; function: " << func->name << '\n'; + Flat::verifyFlatness(func); + // Build the data-flow IR. + DataFlow::Graph graph; + graph.build(func, getModule()); + if (debug() >= 2) { + dump(graph, std::cout); + } + // Build the local graph data structure. + LocalGraph localGraph(func); + localGraph.computeInfluences(); + // If we only want single-use nodes, exclude all the others. + std::unordered_set excludeAsChildren; + if (singleUseOnly) { + for (auto& nodePtr : graph.nodes) { + auto* node = nodePtr.get(); + if (node->origin) { + // TODO: work for identical origins could be saved + auto uses = + DataFlow::UseFinder().getUses(node->origin, graph, localGraph); + if (debug() >= 2) { + std::cout << "following node has " << uses.size() << " uses\n"; + dump(node, std::cout); + } + if (uses.size() > 1) { + excludeAsChildren.insert(node); + } + } + } + } + // Emit possible traces. + for (auto& nodePtr : graph.nodes) { + auto* node = nodePtr.get(); + // Trace + if (DataFlow::Trace::isTraceable(node)) { + DataFlow::Trace trace(graph, node, excludeAsChildren, localGraph); + if (!trace.isBad()) { + DataFlow::Printer printer(graph, trace); + if (singleUseOnly) { + assert(!printer.printedHasExternalUses); + } + } + } + } + } +}; + +Pass* createSouperifyPass() { return new Souperify(false); } + +Pass* createSouperifySingleUsePass() { return new Souperify(true); } + +} // namespace wasm diff --git a/binaryen/src/passes/SpillPointers.cpp b/binaryen/src/passes/SpillPointers.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/passes/SpillPointers.cpp @@ -0,0 +1,206 @@ +/* + * Copyright 2017 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// Spills values that might be pointers to the C stack. This allows +// Boehm-style GC to see them properly. +// +// To reduce the overhead of the extra operations added here, you +// should probably run optimizations after doing it. +// TODO: add a dead store elimination pass, which would help here +// +// * There is currently no check that there is enough stack space. +// + +#include "abi/abi.h" +#include "abi/stack.h" +#include "cfg/liveness-traversal.h" +#include "pass.h" +#include "wasm-builder.h" +#include "wasm.h" + +namespace wasm { + +struct SpillPointers + : public WalkerPass>> { + bool isFunctionParallel() override { return true; } + + Pass* create() override { return new SpillPointers; } + + // a mapping of the pointers to all the spillable things. We need to know + // how to replace them, and as we spill we may modify them. This map + // gives us, for an Expression** seen during the walk (and placed in the + // basic block, which is what we iterate on for efficiency) => the + // current actual pointer, which may have moded + std::unordered_map actualPointers; + + // note calls in basic blocks + template void visitSpillable(T* curr) { + // if in unreachable code, ignore + if (!currBasicBlock) { + return; + } + auto* pointer = getCurrentPointer(); + currBasicBlock->contents.actions.emplace_back(pointer); + // starts out as correct, may change later + actualPointers[pointer] = pointer; + } + + void visitCall(Call* curr) { visitSpillable(curr); } + void visitCallIndirect(CallIndirect* curr) { visitSpillable(curr); } + + // main entry point + + void doWalkFunction(Function* func) { + if (!canRun(func)) { + return; + } + super::doWalkFunction(func); + spillPointers(); + } + + // map pointers to their offset in the spill area + typedef std::unordered_map PointerMap; + + void spillPointers() { + // we only care about possible pointers + auto* func = getFunction(); + PointerMap pointerMap; + for (Index i = 0; i < func->getNumLocals(); i++) { + if (func->getLocalType(i) == ABI::PointerType) { + auto offset = pointerMap.size() * ABI::PointerType.getByteSize(); + pointerMap[i] = offset; + } + } + // find calls and spill around them + bool spilled = false; + Index spillLocal = -1; + for (auto& curr : basicBlocks) { + if (liveBlocks.count(curr.get()) == 0) { + continue; // ignore dead blocks + } + auto& liveness = curr->contents; + auto& actions = liveness.actions; + Index lastCall = -1; + for (Index i = 0; i < actions.size(); i++) { + auto& action = liveness.actions[i]; + if (action.isOther()) { + lastCall = i; + } + } + if (lastCall == Index(-1)) { + continue; // nothing to see here + } + // scan through the block, spilling around the calls + // TODO: we can filter on pointerMap everywhere + SetOfLocals live = liveness.end; + for (int i = int(actions.size()) - 1; i >= 0; i--) { + auto& action = actions[i]; + if (action.isGet()) { + live.insert(action.index); + } else if (action.isSet()) { + live.erase(action.index); + } else if (action.isOther()) { + std::vector toSpill; + for (auto index : live) { + if (pointerMap.count(index) > 0) { + toSpill.push_back(index); + } + } + if (!toSpill.empty()) { + // we now have a call + the information about which locals + // should be spilled + if (!spilled) { + // prepare stack support: get a pointer to stack space big enough + // for all our data + spillLocal = Builder::addVar(func, ABI::PointerType); + spilled = true; + } + // the origin was seen at walk, but the thing may have moved + auto* pointer = actualPointers[action.origin]; + spillPointersAroundCall( + pointer, toSpill, spillLocal, pointerMap, func, getModule()); + } + } else { + WASM_UNREACHABLE("unexpected action"); + } + } + } + if (spilled) { + // get the stack space, and set the local to it + ABI::getStackSpace(spillLocal, + func, + ABI::PointerType.getByteSize() * pointerMap.size(), + *getModule()); + } + } + + void spillPointersAroundCall(Expression** origin, + std::vector& toSpill, + Index spillLocal, + PointerMap& pointerMap, + Function* func, + Module* module) { + auto* call = *origin; + if (call->type == Type::unreachable) { + return; // the call is never reached anyhow, ignore + } + Builder builder(*module); + auto* block = builder.makeBlock(); + // move the operands into locals, as we must spill after they are executed + auto handleOperand = [&](Expression*& operand) { + auto temp = builder.addVar(func, operand->type); + auto* set = builder.makeLocalSet(temp, operand); + block->list.push_back(set); + block->finalize(); + if (actualPointers.count(&operand) > 0) { + // this is something we track, and it's moving - update + actualPointers[&operand] = &set->value; + } + operand = builder.makeLocalGet(temp, operand->type); + }; + if (call->is()) { + for (auto*& operand : call->cast()->operands) { + handleOperand(operand); + } + } else if (call->is()) { + for (auto*& operand : call->cast()->operands) { + handleOperand(operand); + } + handleOperand(call->cast()->target); + } else { + WASM_UNREACHABLE("unexpected expr"); + } + // add the spills + for (auto index : toSpill) { + block->list.push_back( + builder.makeStore(ABI::PointerType.getByteSize(), + pointerMap[index], + ABI::PointerType.getByteSize(), + builder.makeLocalGet(spillLocal, ABI::PointerType), + builder.makeLocalGet(index, ABI::PointerType), + ABI::PointerType)); + } + // add the (modified) call + block->list.push_back(call); + block->finalize(); + *origin = block; + } +}; + +Pass* createSpillPointersPass() { return new SpillPointers(); } + +} // namespace wasm diff --git a/binaryen/src/passes/StackCheck.cpp b/binaryen/src/passes/StackCheck.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/passes/StackCheck.cpp @@ -0,0 +1,175 @@ +/* + * Copyright 2020 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// Enforce stack pointer limits. This pass will add checks around all +// assignments to the __stack_pointer global that LLVM uses for its +// shadow stack. +// + +#include "abi/js.h" +#include "ir/import-utils.h" +#include "pass.h" +#include "shared-constants.h" +#include "support/debug.h" +#include "wasm-emscripten.h" + +#define DEBUG_TYPE "stack-check" + +namespace wasm { + +// The base is where the stack begins. As it goes down, that is the highest +// valid address. +static Name STACK_BASE("__stack_base"); +// The limit is the farthest it can grow to, which is the lowest valid address. +static Name STACK_LIMIT("__stack_limit"); +// Exported function to set the base and the limit. +static Name SET_STACK_LIMITS("__set_stack_limits"); + +static void importStackOverflowHandler(Module& module, Name name) { + ImportInfo info(module); + + if (!info.getImportedFunction(ENV, name)) { + auto* import = new Function; + import->name = name; + import->module = ENV; + import->base = name; + import->sig = Signature(Type::none, Type::none); + module.addFunction(import); + } +} + +static void addExportedFunction(Module& module, Function* function) { + module.addFunction(function); + auto export_ = new Export; + export_->name = export_->value = function->name; + export_->kind = ExternalKind::Function; + module.addExport(export_); +} + +static void generateSetStackLimitFunctions(Module& module) { + Builder builder(module); + Function* limitsFunc = builder.makeFunction( + SET_STACK_LIMITS, Signature({Type::i32, Type::i32}, Type::none), {}); + LocalGet* getBase = builder.makeLocalGet(0, Type::i32); + Expression* storeBase = builder.makeGlobalSet(STACK_BASE, getBase); + LocalGet* getLimit = builder.makeLocalGet(1, Type::i32); + Expression* storeLimit = builder.makeGlobalSet(STACK_LIMIT, getLimit); + limitsFunc->body = builder.makeBlock({storeBase, storeLimit}); + addExportedFunction(module, limitsFunc); +} + +struct EnforceStackLimits : public WalkerPass> { + EnforceStackLimits(Global* stackPointer, + Global* stackBase, + Global* stackLimit, + Builder& builder, + Name handler) + : stackPointer(stackPointer), stackBase(stackBase), stackLimit(stackLimit), + builder(builder), handler(handler) {} + + bool isFunctionParallel() override { return true; } + + Pass* create() override { + return new EnforceStackLimits( + stackPointer, stackBase, stackLimit, builder, handler); + } + + Expression* stackBoundsCheck(Function* func, Expression* value) { + // Add a local to store the value of the expression. We need the value + // twice: once to check if it has overflowed, and again to assign to store + // it. + auto newSP = Builder::addVar(func, stackPointer->type); + // If we imported a handler, call it. That can show a nice error in JS. + // Otherwise, just trap. + Expression* handlerExpr; + if (handler.is()) { + handlerExpr = builder.makeCall(handler, {}, Type::none); + } else { + handlerExpr = builder.makeUnreachable(); + } + // If it is >= the base or <= the limit, then error. + auto check = builder.makeIf( + builder.makeBinary( + BinaryOp::OrInt32, + builder.makeBinary( + BinaryOp::GtUInt32, + builder.makeLocalTee(newSP, value, stackPointer->type), + builder.makeGlobalGet(stackBase->name, stackBase->type)), + builder.makeBinary( + BinaryOp::LtUInt32, + builder.makeLocalGet(newSP, stackPointer->type), + builder.makeGlobalGet(stackLimit->name, stackLimit->type))), + handlerExpr); + // (global.set $__stack_pointer (local.get $newSP)) + auto newSet = builder.makeGlobalSet( + stackPointer->name, builder.makeLocalGet(newSP, stackPointer->type)); + return builder.blockify(check, newSet); + } + + void visitGlobalSet(GlobalSet* curr) { + if (getModule()->getGlobalOrNull(curr->name) == stackPointer) { + replaceCurrent(stackBoundsCheck(getFunction(), curr->value)); + } + } + +private: + Global* stackPointer; + Global* stackBase; + Global* stackLimit; + Builder& builder; + Name handler; +}; + +struct StackCheck : public Pass { + void run(PassRunner* runner, Module* module) override { + Global* stackPointer = getStackPointerGlobal(*module); + if (!stackPointer) { + BYN_DEBUG(std::cerr << "no stack pointer found\n"); + return; + } + + Name handler; + auto handlerName = + runner->options.getArgumentOrDefault("stack-check-handler", ""); + if (handlerName != "") { + handler = handlerName; + importStackOverflowHandler(*module, handler); + } + + Builder builder(*module); + Global* stackBase = builder.makeGlobal(STACK_BASE, + stackPointer->type, + builder.makeConst(int32_t(0)), + Builder::Mutable); + module->addGlobal(stackBase); + + Global* stackLimit = builder.makeGlobal(STACK_LIMIT, + stackPointer->type, + builder.makeConst(int32_t(0)), + Builder::Mutable); + module->addGlobal(stackLimit); + + PassRunner innerRunner(module); + EnforceStackLimits(stackPointer, stackBase, stackLimit, builder, handler) + .run(&innerRunner, module); + generateSetStackLimitFunctions(*module); + } +}; + +Pass* createStackCheckPass() { return new StackCheck; } + +} // namespace wasm diff --git a/binaryen/src/passes/StackIR.cpp b/binaryen/src/passes/StackIR.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/passes/StackIR.cpp @@ -0,0 +1,346 @@ +/* + * Copyright 2018 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// Operations on Stack IR. +// + +#include "ir/iteration.h" +#include "ir/local-graph.h" +#include "pass.h" +#include "wasm-stack.h" +#include "wasm.h" + +namespace wasm { + +// Generate Stack IR from Binaryen IR + +struct GenerateStackIR : public WalkerPass> { + bool isFunctionParallel() override { return true; } + + Pass* create() override { return new GenerateStackIR; } + + bool modifiesBinaryenIR() override { return false; } + + void doWalkFunction(Function* func) { + StackIRGenerator stackIRGen(*getModule(), func); + stackIRGen.write(); + func->stackIR = make_unique(); + func->stackIR->swap(stackIRGen.getStackIR()); + } +}; + +Pass* createGenerateStackIRPass() { return new GenerateStackIR(); } + +// Optimize + +class StackIROptimizer { + Function* func; + PassOptions& passOptions; + StackIR& insts; + +public: + StackIROptimizer(Function* func, PassOptions& passOptions) + : func(func), passOptions(passOptions), insts(*func->stackIR.get()) { + assert(func->stackIR); + } + + void run() { + dce(); + // FIXME: local2Stack is currently rather slow (due to localGraph), + // so for now run it only when really optimizing + if (passOptions.optimizeLevel >= 3 || passOptions.shrinkLevel >= 1) { + local2Stack(); + } + removeUnneededBlocks(); + dce(); + } + +private: + // Passes. + + // Remove unreachable code. + void dce() { + bool inUnreachableCode = false; + for (Index i = 0; i < insts.size(); i++) { + auto* inst = insts[i]; + if (!inst) { + continue; + } + if (inUnreachableCode) { + // Does the unreachable code end here? + if (isControlFlowBarrier(inst)) { + inUnreachableCode = false; + } else { + // We can remove this. + removeAt(i); + } + } else if (inst->type == Type::unreachable) { + inUnreachableCode = true; + } + } + } + + // If ordered properly, we can avoid a local.set/local.get pair, + // and use the value directly from the stack, for example + // [..produce a value on the stack..] + // local.set $x + // [..much code..] + // local.get $x + // call $foo ;; use the value, foo(value) + // As long as the code in between does not modify $x, and has + // no control flow branching out, we can remove both the set + // and the get. + void local2Stack() { + // We use the localGraph to tell us if a get-set pair is indeed + // a set that is read by that get, and only that get. Note that we run + // this on the Binaryen IR, so we are assuming that no previous opt + // has changed the interaction of local operations. + // TODO: we can do this a lot faster, as we just care about linear + // control flow. + LocalGraph localGraph(func); + localGraph.computeInfluences(); + // We maintain a stack of relevant values. This contains: + // * a null for each actual value that the value stack would have + // * an index of each LocalSet that *could* be on the value + // stack at that location. + const Index null = -1; + std::vector values; + // We also maintain a stack of values vectors for control flow, + // saving the stack as we enter and restoring it when we exit. + std::vector> savedValues; +#ifdef STACK_OPT_DEBUG + std::cout << "func: " << func->name << '\n' << insts << '\n'; +#endif + for (Index i = 0; i < insts.size(); i++) { + auto* inst = insts[i]; + if (!inst) { + continue; + } + // First, consume values from the stack as required. + auto consumed = getNumConsumedValues(inst); +#ifdef STACK_OPT_DEBUG + std::cout << " " << i << " : " << *inst << ", " << values.size() + << " on stack, will consume " << consumed << "\n "; + for (auto s : values) + std::cout << s << ' '; + std::cout << '\n'; +#endif + // TODO: currently we run dce before this, but if we didn't, we'd need + // to handle unreachable code here - it's ok to pop multiple values + // there even if the stack is at size 0. + while (consumed > 0) { + assert(values.size() > 0); + // Whenever we hit a possible stack value, kill it - it would + // be consumed here, so we can never optimize to it. + while (values.back() != null) { + values.pop_back(); + assert(values.size() > 0); + } + // Finally, consume the actual value that is consumed here. + values.pop_back(); + consumed--; + } + // After consuming, we can see what to do with this. First, handle + // control flow. + if (isControlFlowBegin(inst)) { + // Save the stack for when we end this control flow. + savedValues.push_back(values); // TODO: optimize copies + values.clear(); + } else if (isControlFlowEnd(inst)) { + assert(!savedValues.empty()); + values = savedValues.back(); + savedValues.pop_back(); + } else if (isControlFlow(inst)) { + // Otherwise, in the middle of control flow, just clear it + values.clear(); + } + // This is something we should handle, look into it. + if (inst->type.isConcrete()) { + bool optimized = false; + if (auto* get = inst->origin->dynCast()) { + // This is a potential optimization opportunity! See if we + // can reach the set. + if (values.size() > 0) { + Index j = values.size() - 1; + while (1) { + // If there's an actual value in the way, we've failed. + auto index = values[j]; + if (index == null) { + break; + } + auto* set = insts[index]->origin->cast(); + if (set->index == get->index) { + // This might be a proper set-get pair, where the set is + // used by this get and nothing else, check that. + auto& sets = localGraph.getSetses[get]; + if (sets.size() == 1 && *sets.begin() == set) { + auto& setInfluences = localGraph.setInfluences[set]; + if (setInfluences.size() == 1) { + assert(*setInfluences.begin() == get); + // Do it! The set and the get can go away, the proper + // value is on the stack. +#ifdef STACK_OPT_DEBUG + std::cout << " stackify the get\n"; +#endif + insts[index] = nullptr; + insts[i] = nullptr; + // Continuing on from here, replace this on the stack + // with a null, representing a regular value. We + // keep possible values above us active - they may + // be optimized later, as they would be pushed after + // us, and used before us, so there is no conflict. + values[j] = null; + optimized = true; + break; + } + } + } + // We failed here. Can we look some more? + if (j == 0) { + break; + } + j--; + } + } + } + if (!optimized) { + // This is an actual regular value on the value stack. + values.push_back(null); + } + } else if (inst->origin->is() && inst->type == Type::none) { + // This set is potentially optimizable later, add to stack. + values.push_back(i); + } + } + } + + // There may be unnecessary blocks we can remove: blocks + // without branches to them are always ok to remove. + // TODO: a branch to a block in an if body can become + // a branch to that if body + void removeUnneededBlocks() { + for (auto*& inst : insts) { + if (!inst) { + continue; + } + if (auto* block = inst->origin->dynCast()) { + if (!BranchUtils::BranchSeeker::has(block, block->name)) { + // TODO optimize, maybe run remove-unused-names + inst = nullptr; + } + } + } + } + + // Utilities. + + // A control flow "barrier" - a point where stack machine + // unreachability ends. + bool isControlFlowBarrier(StackInst* inst) { + switch (inst->op) { + case StackInst::BlockEnd: + case StackInst::IfElse: + case StackInst::IfEnd: + case StackInst::LoopEnd: + case StackInst::Catch: + case StackInst::TryEnd: { + return true; + } + default: { return false; } + } + } + + // A control flow beginning. + bool isControlFlowBegin(StackInst* inst) { + switch (inst->op) { + case StackInst::BlockBegin: + case StackInst::IfBegin: + case StackInst::LoopBegin: + case StackInst::TryBegin: { + return true; + } + default: { return false; } + } + } + + // A control flow ending. + bool isControlFlowEnd(StackInst* inst) { + switch (inst->op) { + case StackInst::BlockEnd: + case StackInst::IfEnd: + case StackInst::LoopEnd: + case StackInst::TryEnd: { + return true; + } + default: { return false; } + } + } + + bool isControlFlow(StackInst* inst) { return inst->op != StackInst::Basic; } + + // Remove the instruction at index i. If the instruction + // is control flow, and so has been expanded to multiple + // instructions, remove them as well. + void removeAt(Index i) { + auto* inst = insts[i]; + insts[i] = nullptr; + if (inst->op == StackInst::Basic) { + return; // that was it + } + auto* origin = inst->origin; + while (1) { + i++; + assert(i < insts.size()); + inst = insts[i]; + insts[i] = nullptr; + if (inst && inst->origin == origin && isControlFlowEnd(inst)) { + return; // that's it, we removed it all + } + } + } + + Index getNumConsumedValues(StackInst* inst) { + if (isControlFlow(inst)) { + // If consumes 1; that's it. + if (inst->op == StackInst::IfBegin) { + return 1; + } + return 0; + } + // Otherwise, for basic instructions, just count the expression children. + return ChildIterator(inst->origin).children.size(); + } +}; + +struct OptimizeStackIR : public WalkerPass> { + bool isFunctionParallel() override { return true; } + + Pass* create() override { return new OptimizeStackIR; } + + bool modifiesBinaryenIR() override { return false; } + + void doWalkFunction(Function* func) { + if (!func->stackIR) { + return; + } + StackIROptimizer(func, getPassOptions()).run(); + } +}; + +Pass* createOptimizeStackIRPass() { return new OptimizeStackIR(); } + +} // namespace wasm diff --git a/binaryen/src/passes/Strip.cpp b/binaryen/src/passes/Strip.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/passes/Strip.cpp @@ -0,0 +1,77 @@ +/* + * Copyright 2018 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// Similar to strip-ing a native binary, this family of passes can +// removes debug info and other things. +// + +#include + +#include "pass.h" +#include "wasm-binary.h" +#include "wasm.h" + +using namespace std; + +namespace wasm { + +struct Strip : public Pass { + // A function that returns true if the method should be removed. + typedef std::function Decider; + Decider decider; + + Strip(Decider decider) : decider(decider) {} + + void run(PassRunner* runner, Module* module) override { + // Remove name and debug sections. + auto& sections = module->userSections; + sections.erase(std::remove_if(sections.begin(), sections.end(), decider), + sections.end()); + // If we're cleaning up debug info, clear on the function and module too. + UserSection temp; + temp.name = BinaryConsts::UserSections::Name; + if (decider(temp)) { + module->clearDebugInfo(); + for (auto& func : module->functions) { + func->clearNames(); + func->clearDebugInfo(); + } + } + } +}; + +Pass* createStripDebugPass() { + return new Strip([&](const UserSection& curr) { + return curr.name == BinaryConsts::UserSections::Name || + curr.name == BinaryConsts::UserSections::SourceMapUrl || + curr.name.find(".debug") == 0 || curr.name.find("reloc..debug") == 0; + }); +} + +Pass* createStripDWARFPass() { + return new Strip([&](const UserSection& curr) { + return curr.name.find(".debug") == 0 || curr.name.find("reloc..debug") == 0; + }); +} + +Pass* createStripProducersPass() { + return new Strip([&](const UserSection& curr) { + return curr.name == BinaryConsts::UserSections::Producers; + }); +} + +} // namespace wasm diff --git a/binaryen/src/passes/StripTargetFeatures.cpp b/binaryen/src/passes/StripTargetFeatures.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/passes/StripTargetFeatures.cpp @@ -0,0 +1,32 @@ +/* + * Copyright 2019 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "pass.h" + +namespace wasm { + +struct StripTargetFeatures : public Pass { + bool isStripped = false; + StripTargetFeatures(bool isStripped) : isStripped(isStripped) {} + void run(PassRunner* runner, Module* module) override { + module->hasFeaturesSection = !isStripped; + } +}; + +Pass* createStripTargetFeaturesPass() { return new StripTargetFeatures(true); } +Pass* createEmitTargetFeaturesPass() { return new StripTargetFeatures(false); } + +} // namespace wasm diff --git a/binaryen/src/passes/TrapMode.cpp b/binaryen/src/passes/TrapMode.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/passes/TrapMode.cpp @@ -0,0 +1,327 @@ +/* + * Copyright 2017 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// Pass that supports potentially-trapping wasm operations. +// For example, integer division traps when dividing by zero, so this pass +// generates a check and replaces the result with zero in that case. +// + +#include "asm_v_wasm.h" +#include "asmjs/shared-constants.h" +#include "ir/trapping.h" +#include "mixed_arena.h" +#include "pass.h" +#include "support/name.h" +#include "wasm-builder.h" +#include "wasm-printing.h" +#include "wasm-type.h" +#include "wasm.h" + +namespace wasm { + +Name I64S_REM("i64s-rem"); +Name I64U_REM("i64u-rem"); +Name I64S_DIV("i64s-div"); +Name I64U_DIV("i64u-div"); + +Name getBinaryFuncName(Binary* curr) { + switch (curr->op) { + case RemSInt32: + return I32S_REM; + case RemUInt32: + return I32U_REM; + case DivSInt32: + return I32S_DIV; + case DivUInt32: + return I32U_DIV; + case RemSInt64: + return I64S_REM; + case RemUInt64: + return I64U_REM; + case DivSInt64: + return I64S_DIV; + case DivUInt64: + return I64U_DIV; + default: + return Name(); + } +} + +Name getUnaryFuncName(Unary* curr) { + switch (curr->op) { + case TruncSFloat32ToInt32: + return F32_TO_INT; + case TruncUFloat32ToInt32: + return F32_TO_UINT; + case TruncSFloat32ToInt64: + return F32_TO_INT64; + case TruncUFloat32ToInt64: + return F32_TO_UINT64; + case TruncSFloat64ToInt32: + return F64_TO_INT; + case TruncUFloat64ToInt32: + return F64_TO_UINT; + case TruncSFloat64ToInt64: + return F64_TO_INT64; + case TruncUFloat64ToInt64: + return F64_TO_UINT64; + default: + return Name(); + } +} + +bool isTruncOpSigned(UnaryOp op) { + switch (op) { + case TruncUFloat32ToInt32: + case TruncUFloat32ToInt64: + case TruncUFloat64ToInt32: + case TruncUFloat64ToInt64: + return false; + default: + return true; + } +} + +Function* generateBinaryFunc(Module& wasm, Binary* curr) { + BinaryOp op = curr->op; + Type type = curr->type; + bool isI64 = type == Type::i64; + Builder builder(wasm); + Expression* result = builder.makeBinary( + op, builder.makeLocalGet(0, type), builder.makeLocalGet(1, type)); + BinaryOp divSIntOp = isI64 ? DivSInt64 : DivSInt32; + UnaryOp eqZOp = isI64 ? EqZInt64 : EqZInt32; + Literal minLit = isI64 ? Literal(std::numeric_limits::min()) + : Literal(std::numeric_limits::min()); + Literal zeroLit = isI64 ? Literal(int64_t(0)) : Literal(int32_t(0)); + if (op == divSIntOp) { + // guard against signed division overflow + BinaryOp eqOp = isI64 ? EqInt64 : EqInt32; + Literal negLit = isI64 ? Literal(int64_t(-1)) : Literal(int32_t(-1)); + result = builder.makeIf( + builder.makeBinary( + AndInt32, + builder.makeBinary( + eqOp, builder.makeLocalGet(0, type), builder.makeConst(minLit)), + builder.makeBinary( + eqOp, builder.makeLocalGet(1, type), builder.makeConst(negLit))), + builder.makeConst(zeroLit), + result); + } + auto func = new Function; + func->name = getBinaryFuncName(curr); + func->sig = Signature({type, type}, type); + func->body = + builder.makeIf(builder.makeUnary(eqZOp, builder.makeLocalGet(1, type)), + builder.makeConst(zeroLit), + result); + return func; +} + +template +void makeClampLimitLiterals(Literal& iMin, Literal& fMin, Literal& fMax) { + IntType minVal = std::numeric_limits::min(); + IntType maxVal = std::numeric_limits::max(); + iMin = Literal(minVal); + fMin = Literal(FloatType(minVal) - 1); + fMax = Literal(FloatType(maxVal) + 1); +} + +Function* generateUnaryFunc(Module& wasm, Unary* curr) { + Type type = curr->value->type; + Type retType = curr->type; + UnaryOp truncOp = curr->op; + bool isF64 = type == Type::f64; + + Builder builder(wasm); + + BinaryOp leOp = isF64 ? LeFloat64 : LeFloat32; + BinaryOp geOp = isF64 ? GeFloat64 : GeFloat32; + BinaryOp neOp = isF64 ? NeFloat64 : NeFloat32; + + Literal iMin, fMin, fMax; + switch (truncOp) { + case TruncSFloat32ToInt32: + makeClampLimitLiterals(iMin, fMin, fMax); + break; + case TruncUFloat32ToInt32: + makeClampLimitLiterals(iMin, fMin, fMax); + break; + case TruncSFloat32ToInt64: + makeClampLimitLiterals(iMin, fMin, fMax); + break; + case TruncUFloat32ToInt64: + makeClampLimitLiterals(iMin, fMin, fMax); + break; + case TruncSFloat64ToInt32: + makeClampLimitLiterals(iMin, fMin, fMax); + break; + case TruncUFloat64ToInt32: + makeClampLimitLiterals(iMin, fMin, fMax); + break; + case TruncSFloat64ToInt64: + makeClampLimitLiterals(iMin, fMin, fMax); + break; + case TruncUFloat64ToInt64: + makeClampLimitLiterals(iMin, fMin, fMax); + break; + default: + WASM_UNREACHABLE("unexpected op"); + } + + auto func = new Function; + func->name = getUnaryFuncName(curr); + func->sig = Signature(type, retType); + func->body = builder.makeUnary(truncOp, builder.makeLocalGet(0, type)); + // too small XXX this is different than asm.js, which does frem. here we + // clamp, which is much simpler/faster, and similar to native builds + func->body = builder.makeIf(builder.makeBinary(leOp, + builder.makeLocalGet(0, type), + builder.makeConst(fMin)), + builder.makeConst(iMin), + func->body); + // too big XXX see above + func->body = builder.makeIf( + builder.makeBinary( + geOp, builder.makeLocalGet(0, type), builder.makeConst(fMax)), + // NB: min here as well. anything out of range => to the min + builder.makeConst(iMin), + func->body); + // nan + func->body = builder.makeIf( + builder.makeBinary( + neOp, builder.makeLocalGet(0, type), builder.makeLocalGet(0, type)), + // NB: min here as well. anything invalid => to the min + builder.makeConst(iMin), + func->body); + return func; +} + +void ensureBinaryFunc(Binary* curr, + Module& wasm, + TrappingFunctionContainer& trappingFunctions) { + Name name = getBinaryFuncName(curr); + if (trappingFunctions.hasFunction(name)) { + return; + } + trappingFunctions.addFunction(generateBinaryFunc(wasm, curr)); +} + +void ensureUnaryFunc(Unary* curr, + Module& wasm, + TrappingFunctionContainer& trappingFunctions) { + Name name = getUnaryFuncName(curr); + if (trappingFunctions.hasFunction(name)) { + return; + } + trappingFunctions.addFunction(generateUnaryFunc(wasm, curr)); +} + +void ensureF64ToI64JSImport(TrappingFunctionContainer& trappingFunctions) { + if (trappingFunctions.hasImport(F64_TO_INT)) { + return; + } + + // f64-to-int = asm2wasm.f64-to-int; + auto import = new Function; + import->name = F64_TO_INT; + import->module = ASM2WASM; + import->base = F64_TO_INT; + import->sig = Signature(Type::f64, Type::i32); + trappingFunctions.addImport(import); +} + +Expression* makeTrappingBinary(Binary* curr, + TrappingFunctionContainer& trappingFunctions) { + Name name = getBinaryFuncName(curr); + if (!name.is() || trappingFunctions.getMode() == TrapMode::Allow) { + return curr; + } + + // the wasm operation might trap if done over 0, so generate a safe call + Type type = curr->type; + Module& wasm = trappingFunctions.getModule(); + Builder builder(wasm); + ensureBinaryFunc(curr, wasm, trappingFunctions); + return builder.makeCall(name, {curr->left, curr->right}, type); +} + +Expression* makeTrappingUnary(Unary* curr, + TrappingFunctionContainer& trappingFunctions) { + Name name = getUnaryFuncName(curr); + TrapMode mode = trappingFunctions.getMode(); + if (!name.is() || mode == TrapMode::Allow) { + return curr; + } + + Module& wasm = trappingFunctions.getModule(); + Builder builder(wasm); + // WebAssembly traps on float-to-int overflows, but asm.js wouldn't, so we + // must do something We can handle this in one of two ways: clamping, which is + // fast, or JS, which is precisely like JS but in order to do that we do a + // slow ffi If i64, there is no "JS" way to handle this, as no i64s in JS, so + // always clamp if we don't allow traps asm.js doesn't have unsigned + // f64-to-int, so just use the signed one. + if (curr->type != Type::i64 && mode == TrapMode::JS) { + // WebAssembly traps on float-to-int overflows, but asm.js wouldn't, so we + // must emulate that + ensureF64ToI64JSImport(trappingFunctions); + Expression* f64Value = ensureDouble(curr->value, wasm.allocator); + return builder.makeCall(F64_TO_INT, {f64Value}, Type::i32); + } + + ensureUnaryFunc(curr, wasm, trappingFunctions); + return builder.makeCall(name, {curr->value}, curr->type); +} + +struct TrapModePass : public WalkerPass> { +public: + // Needs to be non-parallel so that visitModule gets called after visiting + // each node in the module, so we can add the functions that we created. + bool isFunctionParallel() override { return false; } + + TrapModePass(TrapMode mode) : mode(mode) { assert(mode != TrapMode::Allow); } + + Pass* create() override { return new TrapModePass(mode); } + + void visitUnary(Unary* curr) { + replaceCurrent(makeTrappingUnary(curr, *trappingFunctions)); + } + + void visitBinary(Binary* curr) { + replaceCurrent(makeTrappingBinary(curr, *trappingFunctions)); + } + + void visitModule(Module* curr) { trappingFunctions->addToModule(); } + + void doWalkModule(Module* module) { + trappingFunctions = make_unique(mode, *module); + super::doWalkModule(module); + } + +private: + TrapMode mode; + // Need to defer adding generated functions because adding functions while + // iterating over existing functions causes problems. + std::unique_ptr trappingFunctions; +}; + +Pass* createTrapModeClamp() { return new TrapModePass(TrapMode::Clamp); } + +Pass* createTrapModeJS() { return new TrapModePass(TrapMode::JS); } + +} // namespace wasm diff --git a/binaryen/src/passes/Untee.cpp b/binaryen/src/passes/Untee.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/passes/Untee.cpp @@ -0,0 +1,55 @@ +/* + * Copyright 2017 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// Removes local.tees, replacing them with gets and sets. +// +// This makes the code "flatter", with less nested side +// effects. That can make some passes, like CodePushing, +// more effective. +// + +#include +#include +#include + +namespace wasm { + +struct Untee : public WalkerPass> { + bool isFunctionParallel() override { return true; } + + Pass* create() override { return new Untee; } + + void visitLocalSet(LocalSet* curr) { + if (curr->isTee()) { + if (curr->value->type == Type::unreachable) { + // we don't reach the tee, just remove it + replaceCurrent(curr->value); + } else { + // a normal tee. replace with set and get + Builder builder(*getModule()); + LocalGet* get = builder.makeLocalGet( + curr->index, getFunction()->getLocalType(curr->index)); + replaceCurrent(builder.makeSequence(curr, get)); + curr->makeSet(); + } + } + } +}; + +Pass* createUnteePass() { return new Untee(); } + +} // namespace wasm diff --git a/binaryen/src/passes/Vacuum.cpp b/binaryen/src/passes/Vacuum.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/passes/Vacuum.cpp @@ -0,0 +1,449 @@ +/* + * Copyright 2016 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// Removes obviously unneeded code +// + +#include +#include +#include +#include +#include +#include +#include +#include + +namespace wasm { + +struct Vacuum : public WalkerPass> { + bool isFunctionParallel() override { return true; } + + Pass* create() override { return new Vacuum; } + + TypeUpdater typeUpdater; + + Expression* replaceCurrent(Expression* expression) { + auto* old = getCurrent(); + super::replaceCurrent(expression); + // also update the type updater + typeUpdater.noteReplacement(old, expression); + return expression; + } + + void doWalkFunction(Function* func) { + typeUpdater.walk(func->body); + walk(func->body); + } + + // Returns nullptr if curr is dead, curr if it must stay as is, or another + // node if it can be replaced. Takes into account: + // * The result may be used or unused. + // * The type may or may not matter (a drop can drop anything, for example). + Expression* optimize(Expression* curr, bool resultUsed, bool typeMatters) { + FeatureSet features = getModule()->features; + auto type = curr->type; + // An unreachable node must not be changed. + if (type == Type::unreachable) { + return curr; + } + // We iterate on possible replacements. If a replacement changes the type, + // stop and go back. + auto* prev = curr; + while (1) { + if (typeMatters && curr->type != type) { + return prev; + } + prev = curr; + switch (curr->_id) { + case Expression::Id::NopId: + return nullptr; // never needed + + case Expression::Id::BlockId: + return curr; // not always needed, but handled in visitBlock() + case Expression::Id::IfId: + return curr; // not always needed, but handled in visitIf() + case Expression::Id::LoopId: + return curr; // not always needed, but handled in visitLoop() + case Expression::Id::DropId: + return curr; // not always needed, but handled in visitDrop() + case Expression::Id::TryId: + return curr; // not always needed, but handled in visitTry() + + case Expression::Id::BreakId: + case Expression::Id::SwitchId: + case Expression::Id::BrOnExnId: + case Expression::Id::CallId: + case Expression::Id::CallIndirectId: + case Expression::Id::LocalSetId: + case Expression::Id::StoreId: + case Expression::Id::ReturnId: + case Expression::Id::GlobalSetId: + case Expression::Id::MemorySizeId: + case Expression::Id::MemoryGrowId: + case Expression::Id::UnreachableId: + return curr; // always needed + + case Expression::Id::LoadId: { + // it is ok to remove a load if the result is not used, and it has no + // side effects (the load itself may trap, if we are not ignoring such + // things) + auto* load = curr->cast(); + if (!resultUsed && !EffectAnalyzer(getPassOptions(), features, curr) + .hasSideEffects()) { + if (!typeMatters || load->ptr->type == type) { + return load->ptr; + } + } + return curr; + } + case Expression::Id::ConstId: + case Expression::Id::LocalGetId: + case Expression::Id::GlobalGetId: { + if (!resultUsed) { + return nullptr; + } + return curr; + } + + case Expression::Id::UnaryId: + case Expression::Id::BinaryId: + case Expression::Id::SelectId: { + if (resultUsed) { + return curr; // used, keep it + } + // for unary, binary, and select, we need to check their arguments for + // side effects, as well as the node itself, as some unaries and + // binaries have implicit traps + if (auto* unary = curr->dynCast()) { + EffectAnalyzer tester(getPassOptions(), features); + tester.visitUnary(unary); + if (tester.hasSideEffects()) { + return curr; + } + if (EffectAnalyzer(getPassOptions(), features, unary->value) + .hasSideEffects()) { + curr = unary->value; + continue; + } else { + return nullptr; + } + } else if (auto* binary = curr->dynCast()) { + EffectAnalyzer tester(getPassOptions(), features); + tester.visitBinary(binary); + if (tester.hasSideEffects()) { + return curr; + } + if (EffectAnalyzer(getPassOptions(), features, binary->left) + .hasSideEffects()) { + if (EffectAnalyzer(getPassOptions(), features, binary->right) + .hasSideEffects()) { + return curr; // leave them + } else { + curr = binary->left; + continue; + } + } else { + if (EffectAnalyzer(getPassOptions(), features, binary->right) + .hasSideEffects()) { + curr = binary->right; + continue; + } else { + return nullptr; + } + } + } else { + // TODO: if two have side effects, we could replace the select with + // say an add? + auto* select = curr->cast()) { + handleCondition(select->condition); + } else if (auto* sw = curr->dynCast()) { + handleCondition(sw->condition); + // Try to replace switch targets with the default + for (auto& target : sw->targets) { + if (target != sw->default_) { + auto old = target; + target = sw->default_; + if (!tryToReplaceCurrent(curr)) { + target = old; + } + } + } + // Try to shorten the list of targets. + while (sw->targets.size() > 1) { + auto last = sw->targets.back(); + sw->targets.pop_back(); + if (!tryToReplaceCurrent(curr)) { + sw->targets.push_back(last); + break; + } + } + } else if (auto* block = curr->dynCast()) { + if (!shouldTryToReduce()) { + return; + } + // replace a singleton + auto& list = block->list; + if (list.size() == 1 && + !BranchUtils::BranchSeeker::has(block, block->name)) { + if (tryToReplaceCurrent(block->list[0])) { + return; + } + } + // try to get rid of nops + Index i = 0; + while (list.size() > 1 && i < list.size()) { + auto* curr = list[i]; + if (curr->is() && shouldTryToReduce()) { + // try to remove it + for (Index j = i; j < list.size() - 1; j++) { + list[j] = list[j + 1]; + } + list.pop_back(); + if (writeAndTestReduction()) { + std::cerr << "| block-nop removed\n"; + noteReduction(); + return; + } + list.push_back(nullptr); + // we failed; undo + for (Index j = list.size() - 1; j > i; j--) { + list[j] = list[j - 1]; + } + list[i] = curr; + } + i++; + } + return; // nothing more to do + } else if (auto* loop = curr->dynCast()) { + if (shouldTryToReduce() && + !BranchUtils::BranchSeeker::has(loop, loop->name)) { + tryToReplaceCurrent(loop->body); + } + return; // nothing more to do + } + // Finally, try to replace with a child. + for (auto* child : ChildIterator(curr)) { + if (child->type.isConcrete() && curr->type == Type::none) { + if (tryToReplaceCurrent(builder->makeDrop(child))) { + return; + } + } else { + if (tryToReplaceCurrent(child)) { + return; + } + } + } + // If that didn't work, try to replace with a child + a unary conversion, + // but not if it's already unary + if (curr->type.isSingle() && !curr->is()) { + for (auto* child : ChildIterator(curr)) { + if (child->type == curr->type) { + continue; // already tried + } + if (!child->type.isSingle()) { + continue; // no conversion + } + Expression* fixed = nullptr; + TODO_SINGLE_COMPOUND(curr->type); + switch (curr->type.getBasic()) { + case Type::i32: { + TODO_SINGLE_COMPOUND(child->type); + switch (child->type.getBasic()) { + case Type::i32: + WASM_UNREACHABLE("invalid type"); + case Type::i64: + fixed = builder->makeUnary(WrapInt64, child); + break; + case Type::f32: + fixed = builder->makeUnary(TruncSFloat32ToInt32, child); + break; + case Type::f64: + fixed = builder->makeUnary(TruncSFloat64ToInt32, child); + break; + case Type::v128: + case Type::funcref: + case Type::externref: + case Type::exnref: + case Type::anyref: + case Type::eqref: + case Type::i31ref: + continue; // not implemented yet + case Type::none: + case Type::unreachable: + WASM_UNREACHABLE("unexpected type"); + } + break; + } + case Type::i64: { + TODO_SINGLE_COMPOUND(child->type); + switch (child->type.getBasic()) { + case Type::i32: + fixed = builder->makeUnary(ExtendSInt32, child); + break; + case Type::i64: + WASM_UNREACHABLE("invalid type"); + case Type::f32: + fixed = builder->makeUnary(TruncSFloat32ToInt64, child); + break; + case Type::f64: + fixed = builder->makeUnary(TruncSFloat64ToInt64, child); + break; + case Type::v128: + case Type::funcref: + case Type::externref: + case Type::exnref: + case Type::anyref: + case Type::eqref: + case Type::i31ref: + continue; // not implemented yet + case Type::none: + case Type::unreachable: + WASM_UNREACHABLE("unexpected type"); + } + break; + } + case Type::f32: { + TODO_SINGLE_COMPOUND(child->type); + switch (child->type.getBasic()) { + case Type::i32: + fixed = builder->makeUnary(ConvertSInt32ToFloat32, child); + break; + case Type::i64: + fixed = builder->makeUnary(ConvertSInt64ToFloat32, child); + break; + case Type::f32: + WASM_UNREACHABLE("unexpected type"); + case Type::f64: + fixed = builder->makeUnary(DemoteFloat64, child); + break; + case Type::v128: + case Type::funcref: + case Type::externref: + case Type::exnref: + case Type::anyref: + case Type::eqref: + case Type::i31ref: + continue; // not implemented yet + case Type::none: + case Type::unreachable: + WASM_UNREACHABLE("unexpected type"); + } + break; + } + case Type::f64: { + TODO_SINGLE_COMPOUND(child->type); + switch (child->type.getBasic()) { + case Type::i32: + fixed = builder->makeUnary(ConvertSInt32ToFloat64, child); + break; + case Type::i64: + fixed = builder->makeUnary(ConvertSInt64ToFloat64, child); + break; + case Type::f32: + fixed = builder->makeUnary(PromoteFloat32, child); + break; + case Type::f64: + WASM_UNREACHABLE("unexpected type"); + case Type::v128: + case Type::funcref: + case Type::externref: + case Type::exnref: + case Type::anyref: + case Type::eqref: + case Type::i31ref: + continue; // not implemented yet + case Type::none: + case Type::unreachable: + WASM_UNREACHABLE("unexpected type"); + } + break; + } + case Type::v128: + case Type::funcref: + case Type::externref: + case Type::exnref: + case Type::anyref: + case Type::eqref: + case Type::i31ref: + continue; // not implemented yet + case Type::none: + case Type::unreachable: + WASM_UNREACHABLE("unexpected type"); + } + assert(fixed->type == curr->type); + if (tryToReplaceCurrent(fixed)) { + return; + } + } + } + } + + void visitFunction(Function* curr) { + if (!curr->imported()) { + // extra chance to work on the function toplevel element, as if it can + // be reduced it's great + visitExpression(curr->body); + } + // finish function + funcsSeen++; + static int last = 0; + int percentage = (100 * funcsSeen) / getModule()->functions.size(); + if (std::abs(percentage - last) >= 5) { + std::cerr << "| " << percentage << "% of funcs complete\n"; + last = percentage; + } + } + + // TODO: bisection on segment shrinking? + + void visitTable(Table* curr) { + std::cerr << "| try to simplify table\n"; + Name first; + for (auto& segment : curr->segments) { + for (auto item : segment.data) { + first = item; + break; + } + if (!first.isNull()) { + break; + } + } + visitSegmented(curr, first, 100); + } + + void visitMemory(Memory* curr) { + std::cerr << "| try to simplify memory\n"; + visitSegmented(curr, 0, 2); + } + + template + void visitSegmented(T* curr, U zero, size_t bonus) { + // try to reduce to first function. first, shrink segment elements. + // while we are shrinking successfully, keep going exponentially. + bool justShrank = false; + bool shrank = false; + for (auto& segment : curr->segments) { + auto& data = segment.data; + // when we succeed, try to shrink by more and more, similar to bisection + size_t skip = 1; + for (size_t i = 0; i < data.size() && !data.empty(); i++) { + if (!justShrank && !shouldTryToReduce(bonus)) { + continue; + } + auto save = data; + for (size_t j = 0; j < skip; j++) { + if (!data.empty()) { + data.pop_back(); + } + } + auto justShrank = writeAndTestReduction(); + if (justShrank) { + std::cerr << "| shrank segment (skip: " << skip << ")\n"; + shrank = true; + noteReduction(); + skip = std::min(size_t(factor), 2 * skip); + } else { + data = save; + break; + } + } + } + // the "opposite" of shrinking: copy a 'zero' element + for (auto& segment : curr->segments) { + if (segment.data.empty()) { + continue; + } + for (auto& item : segment.data) { + if (!shouldTryToReduce(bonus)) { + continue; + } + if (item == zero) { + continue; + } + auto save = item; + item = zero; + if (writeAndTestReduction()) { + std::cerr << "| zeroed segment\n"; + noteReduction(); + } else { + item = save; + } + if (shrank) { + // zeroing is fairly inefficient. if we are managing to shrink + // (which we do exponentially), just zero one per segment at most + break; + } + } + } + } + + void visitModule(Module* curr) { + assert(curr == module.get()); + // try to remove functions + std::cerr << "| try to remove functions\n"; + std::vector functionNames; + for (auto& func : module->functions) { + functionNames.push_back(func->name); + } + size_t skip = 1; + // If we just removed some functions in the previous iteration, keep trying + // to remove more as this is one of the most efficient ways to reduce. + bool justRemoved = false; + for (size_t i = 0; i < functionNames.size(); i++) { + if (!justRemoved && + functionsWeTriedToRemove.count(functionNames[i]) == 1 && + !shouldTryToReduce(std::max((factor / 100) + 1, 1000))) { + continue; + } + std::vector names; + for (size_t j = 0; names.size() < skip && i + j < functionNames.size(); + j++) { + auto name = functionNames[i + j]; + if (module->getFunctionOrNull(name)) { + names.push_back(name); + functionsWeTriedToRemove.insert(name); + } + } + if (names.size() == 0) { + continue; + } + std::cout << "| try to remove " << names.size() + << " functions (skip: " << skip << ")\n"; + justRemoved = tryToRemoveFunctions(names); + if (justRemoved) { + noteReduction(names.size()); + i += skip; + skip = std::min(size_t(factor), 2 * skip); + } else { + skip = std::max(skip / 2, size_t(1)); // or 1? + } + } + // try to remove exports + std::cerr << "| try to remove exports (with factor " << factor << ")\n"; + std::vector exports; + for (auto& exp : module->exports) { + exports.push_back(*exp); + } + skip = 1; + for (size_t i = 0; i < exports.size(); i++) { + if (!shouldTryToReduce(std::max((factor / 100) + 1, 1000))) { + continue; + } + std::vector currExports; + for (size_t j = 0; currExports.size() < skip && i + j < exports.size(); + j++) { + auto exp = exports[i + j]; + if (module->getExportOrNull(exp.name)) { + currExports.push_back(exp); + module->removeExport(exp.name); + } + } + ProgramResult result; + if (!writeAndTestReduction(result)) { + for (auto exp : currExports) { + module->addExport(new Export(exp)); + } + skip = std::max(skip / 2, size_t(1)); // or 1? + } else { + std::cerr << "| removed " << currExports.size() << " exports\n"; + noteReduction(currExports.size()); + i += skip; + skip = std::min(size_t(factor), 2 * skip); + } + } + // If we are left with a single function that is not exported or used in + // a table, that is useful as then we can change the return type. + if (module->functions.size() == 1 && module->exports.empty() && + module->table.segments.empty()) { + auto* func = module->functions[0].get(); + // We can't remove something that might have breaks to it. + if (!func->imported() && !Properties::isNamedControlFlow(func->body)) { + auto funcSig = func->sig; + auto* funcBody = func->body; + for (auto* child : ChildIterator(func->body)) { + if (!(child->type.isConcrete() || child->type == Type::none)) { + continue; // not something a function can return + } + // Try to replace the body with the child, fixing up the function + // to accept it. + func->sig.results = child->type; + func->body = child; + if (writeAndTestReduction()) { + // great, we succeeded! + std::cerr << "| altered function result type\n"; + noteReduction(1); + break; + } + // Undo. + func->sig = funcSig; + func->body = funcBody; + } + } + } + } + + bool tryToRemoveFunctions(std::vector names) { + for (auto name : names) { + module->removeFunction(name); + } + + // remove all references to them + struct FunctionReferenceRemover + : public PostWalker { + std::unordered_set names; + std::vector exportsToRemove; + + FunctionReferenceRemover(std::vector& vec) { + for (auto name : vec) { + names.insert(name); + } + } + void visitCall(Call* curr) { + if (names.count(curr->target)) { + replaceCurrent(Builder(*getModule()).replaceWithIdenticalType(curr)); + } + } + void visitExport(Export* curr) { + if (names.count(curr->value)) { + exportsToRemove.push_back(curr->name); + } + } + void visitTable(Table* curr) { + Name other; + for (auto& segment : curr->segments) { + for (auto name : segment.data) { + if (!names.count(name)) { + other = name; + break; + } + } + if (!other.isNull()) { + break; + } + } + if (other.isNull()) { + return; // we failed to find a replacement + } + for (auto& segment : curr->segments) { + for (auto& name : segment.data) { + if (names.count(name)) { + name = other; + } + } + } + } + void doWalkModule(Module* module) { + PostWalker::doWalkModule(module); + for (auto name : exportsToRemove) { + module->removeExport(name); + } + } + }; + FunctionReferenceRemover referenceRemover(names); + referenceRemover.walkModule(module.get()); + + if (WasmValidator().validate( + *module, WasmValidator::Globally | WasmValidator::Quiet) && + writeAndTestReduction()) { + std::cerr << "| removed " << names.size() << " functions\n"; + return true; + } else { + loadWorking(); // restore it from orbit + return false; + } + } + + // helpers + + // try to replace condition with always true and always false + void handleCondition(Expression*& condition) { + if (!condition) { + return; + } + if (condition->is()) { + return; + } + auto* c = builder->makeConst(int32_t(0)); + if (!tryToReplaceChild(condition, c)) { + c->value = Literal(int32_t(1)); + tryToReplaceChild(condition, c); + } + } + + bool tryToReduceCurrentToNop() { + auto* curr = getCurrent(); + if (curr->is()) { + return false; + } + // try to replace with a trivial value + Nop nop; + if (tryToReplaceCurrent(&nop)) { + replaceCurrent(builder->makeNop()); + return true; + } + return false; + } + + // try to replace a concrete value with a trivial constant + bool tryToReduceCurrentToConst() { + auto* curr = getCurrent(); + if (curr->is()) { + return false; + } + // try to replace with a trivial value + if (curr->type.isNullable()) { + RefNull* n = builder->makeRefNull(curr->type); + return tryToReplaceCurrent(n); + } + if (curr->type.isTuple()) { + Expression* n = + builder->makeConstantExpression(Literal::makeZeros(curr->type)); + return tryToReplaceCurrent(n); + } + Const* c = builder->makeConst(int32_t(0)); + if (tryToReplaceCurrent(c)) { + return true; + } + c->value = Literal::makeOne(curr->type); + c->type = curr->type; + return tryToReplaceCurrent(c); + } + + bool tryToReduceCurrentToUnreachable() { + auto* curr = getCurrent(); + if (curr->is()) { + return false; + } + // try to replace with a trivial value + Unreachable un; + if (tryToReplaceCurrent(&un)) { + replaceCurrent(builder->makeUnreachable()); + return true; + } + // maybe a return? TODO + return false; + } +}; + +// +// main +// + +int main(int argc, const char* argv[]) { + std::string input, test, working, command; + // By default, look for binaries alongside our own binary. + std::string binDir = Path::getDirName(argv[0]); + bool binary = true, deNan = false, verbose = false, debugInfo = false, + force = false; + Options options("wasm-reduce", + "Reduce a wasm file to a smaller one that has the same " + "behavior on a given command"); + options + .add("--command", + "-cmd", + "The command to run on the test, that we want to reduce while keeping " + "the command's output identical. " + "We look at the command's return code and stdout here (TODO: stderr), " + "and we reduce while keeping those unchanged.", + Options::Arguments::One, + [&](Options* o, const std::string& argument) { command = argument; }) + .add("--test", + "-t", + "Test file (this will be written to to test, the given command should " + "read it when we call it)", + Options::Arguments::One, + [&](Options* o, const std::string& argument) { test = argument; }) + .add("--working", + "-w", + "Working file (this will contain the current good state while doing " + "temporary computations, " + "and will contain the final best result at the end)", + Options::Arguments::One, + [&](Options* o, const std::string& argument) { working = argument; }) + .add("--binaries", + "-b", + "binaryen binaries location (bin/ directory)", + Options::Arguments::One, + [&](Options* o, const std::string& argument) { + // Add separator just in case + binDir = argument + Path::getPathSeparator(); + }) + .add("--text", + "-S", + "Emit intermediate files as text, instead of binary (also make sure " + "the test and working files have a .wat or .wast suffix)", + Options::Arguments::Zero, + [&](Options* o, const std::string& argument) { binary = false; }) + .add("--denan", + "", + "Avoid nans when reducing", + Options::Arguments::Zero, + [&](Options* o, const std::string& argument) { deNan = true; }) + .add("--verbose", + "-v", + "Verbose output mode", + Options::Arguments::Zero, + [&](Options* o, const std::string& argument) { verbose = true; }) + .add("--debugInfo", + "-g", + "Keep debug info in binaries", + Options::Arguments::Zero, + [&](Options* o, const std::string& argument) { debugInfo = true; }) + .add("--force", + "-f", + "Force the reduction attempt, ignoring problems that imply it is " + "unlikely to succeed", + Options::Arguments::Zero, + [&](Options* o, const std::string& argument) { force = true; }) + .add("--timeout", + "-to", + "A timeout to apply to each execution of the command, in seconds " + "(default: 2)", + Options::Arguments::One, + [&](Options* o, const std::string& argument) { + timeout = atoi(argument.c_str()); + std::cout << "|applying timeout: " << timeout << "\n"; + }) + .add_positional( + "INFILE", + Options::Arguments::One, + [&](Options* o, const std::string& argument) { input = argument; }); + options.parse(argc, argv); + + if (test.size() == 0) { + Fatal() << "test file not provided\n"; + } + if (working.size() == 0) { + Fatal() << "working file not provided\n"; + } + + if (!binary) { + Colors::setEnabled(false); + } + + Path::setBinaryenBinDir(binDir); + + std::cerr << "|wasm-reduce\n"; + std::cerr << "|input: " << input << '\n'; + std::cerr << "|test: " << test << '\n'; + std::cerr << "|working: " << working << '\n'; + std::cerr << "|bin dir: " << binDir << '\n'; + + // get the expected output + copy_file(input, test); + expected.getFromExecution(command); + + std::cerr << "|expected result:\n" << expected << '\n'; + std::cerr << "|!! Make sure the above is what you expect! !!\n\n"; + + auto stopIfNotForced = [&](std::string message, ProgramResult& result) { + std::cerr << "|! " << message << '\n' << result << '\n'; + if (!force) { + Fatal() << "|! stopping, as it is very unlikely reduction can succeed " + "(use -f to ignore this check)"; + } + }; + + if (expected.time + 1 >= timeout) { + stopIfNotForced("execution time is dangerously close to the timeout - you " + "should probably increase the timeout", + expected); + } + + std::cerr + << "|checking that command has different behavior on invalid binary (this " + "verifies that the test file is used by the command)\n"; + { + { + std::ofstream dst(test, std::ios::binary); + dst << "waka waka\n"; + } + ProgramResult result(command); + if (result == expected) { + stopIfNotForced( + "running command on an invalid module should give different results", + result); + } + } + + std::cerr << "|checking that command has expected behavior on canonicalized " + "(read-written) binary\n"; + { + // read and write it + auto cmd = Path::getBinaryenBinaryTool("wasm-opt") + " " + input + + " --detect-features -o " + test; + if (!binary) { + cmd += " -S"; + } + ProgramResult readWrite(cmd); + if (readWrite.failed()) { + stopIfNotForced("failed to read and write the binary", readWrite); + } else { + ProgramResult result(command); + if (result != expected) { + stopIfNotForced("running command on the canonicalized module should " + "give the same results", + result); + } + } + } + + copy_file(input, working); + auto workingSize = file_size(working); + std::cerr << "|input size: " << workingSize << "\n"; + + std::cerr << "|starting reduction!\n"; + + int factor = workingSize * 2; + size_t lastDestructiveReductions = 0; + size_t lastPostPassesSize = 0; + + bool stopping = false; + + while (1) { + Reducer reducer(command, test, working, binary, deNan, verbose, debugInfo); + + // run binaryen optimization passes to reduce. passes are fast to run + // and can often reduce large amounts of code efficiently, as opposed + // to detructive reduction (i.e., that doesn't preserve correctness as + // passes do) since destrucive must operate one change at a time + std::cerr << "| reduce using passes...\n"; + auto oldSize = file_size(working); + reducer.reduceUsingPasses(); + auto newSize = file_size(working); + auto passProgress = oldSize - newSize; + std::cerr << "| after pass reduction: " << newSize << "\n"; + + // always stop after a pass reduction attempt, for final cleanup + if (stopping) { + break; + } + + // check if the full cycle (destructive/passes) has helped or not + if (lastPostPassesSize && newSize >= lastPostPassesSize) { + std::cerr << "| progress has stopped, skipping to the end\n"; + if (factor == 1) { + // this is after doing work with factor 1, so after the remaining work, + // stop + stopping = true; + } else { + // just try to remove all we can and finish up + factor = 1; + } + } + lastPostPassesSize = newSize; + + // if destructive reductions lead to useful proportionate pass reductions, + // keep going at the same factor, as pass reductions are far faster + std::cerr << "| pass progress: " << passProgress + << ", last destructive: " << lastDestructiveReductions << '\n'; + if (passProgress >= 4 * lastDestructiveReductions) { + // don't change + std::cerr << "| progress is good, do not quickly decrease factor\n"; + } else { + if (factor > 10) { + factor = (factor / 3) + 1; + } else { + factor = (factor + 1) / 2; // stable on 1 + } + } + + // no point in a factor lorger than the size + assert(newSize > 4); // wasm modules are >4 bytes anyhow + factor = std::min(factor, int(newSize) / 4); + + // try to reduce destructively. if a high factor fails to find anything, + // quickly try a lower one (no point in doing passes until we reduce + // destructively at least a little) + while (1) { + std::cerr << "| reduce destructively... (factor: " << factor << ")\n"; + lastDestructiveReductions = reducer.reduceDestructively(factor); + if (lastDestructiveReductions > 0) { + break; + } + // we failed to reduce destructively + if (factor == 1) { + stopping = true; + break; + } + factor = std::max( + 1, factor / 4); // quickly now, try to find *something* we can reduce + } + + std::cerr << "| destructive reduction led to size: " << file_size(working) + << '\n'; + } + std::cerr << "|finished, final size: " << file_size(working) << "\n"; + copy_file(working, test); // just to avoid confusion +} diff --git a/binaryen/src/tools/wasm-shell.cpp b/binaryen/src/tools/wasm-shell.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/tools/wasm-shell.cpp @@ -0,0 +1,339 @@ +/* + * Copyright 2015 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// A WebAssembly shell, loads a .wast file (WebAssembly in S-Expression format) +// and executes it. This provides similar functionality as the reference +// interpreter, like assert_* calls, so it can run the spec test suite. +// + +#include + +#include "execution-results.h" +#include "pass.h" +#include "shell-interface.h" +#include "support/command-line.h" +#include "support/file.h" +#include "wasm-interpreter.h" +#include "wasm-printing.h" +#include "wasm-s-parser.h" +#include "wasm-validator.h" + +using namespace cashew; +using namespace wasm; + +Name ASSERT_RETURN("assert_return"); +Name ASSERT_TRAP("assert_trap"); +Name ASSERT_INVALID("assert_invalid"); +Name ASSERT_MALFORMED("assert_malformed"); +Name ASSERT_UNLINKABLE("assert_unlinkable"); +Name INVOKE("invoke"); +Name GET("get"); + +// Modules named in the file + +std::map> modules; +std::map> builders; +std::map> interfaces; +std::map> instances; + +// +// An operation on a module +// + +struct Operation { + ModuleInstance* instance; + Name operation; + Name name; + LiteralList arguments; + + Operation(Element& element, + ModuleInstance* instanceInit, + SExpressionWasmBuilder& builder) + : instance(instanceInit) { + operation = element[0]->str(); + Index i = 1; + if (element.size() >= 3 && element[2]->isStr()) { + // module also specified + Name moduleName = element[i++]->str(); + instance = instances[moduleName].get(); + } + name = element[i++]->str(); + for (size_t j = i; j < element.size(); j++) { + Expression* argument = builder.parseExpression(*element[j]); + arguments.push_back(getLiteralFromConstExpression(argument)); + } + } + + Literals operate() { + if (operation == INVOKE) { + return instance->callExport(name, arguments); + } else if (operation == GET) { + return {instance->getExport(name)}; + } else { + WASM_UNREACHABLE("unknown operation"); + } + } +}; + +static void run_asserts(Name moduleName, + size_t* i, + bool* checked, + Module* wasm, + Element* root, + SExpressionWasmBuilder* builder, + Name entry) { + ModuleInstance* instance = nullptr; + if (wasm) { + // prefix make_unique to work around visual studio bugs + auto tempInterface = wasm::make_unique(); + auto tempInstance = + wasm::make_unique(*wasm, tempInterface.get()); + interfaces[moduleName].swap(tempInterface); + instances[moduleName].swap(tempInstance); + instance = instances[moduleName].get(); + if (entry.is()) { + Function* function = wasm->getFunction(entry); + if (!function) { + std::cerr << "Unknown entry " << entry << std::endl; + } else { + LiteralList arguments; + for (const auto& param : function->sig.params) { + arguments.push_back(Literal(param)); + } + try { + instance->callExport(entry, arguments); + } catch (ExitException&) { + } + } + } + } + while (*i < root->size()) { + Element& curr = *(*root)[*i]; + IString id = curr[0]->str(); + if (id == MODULE) { + break; + } + *checked = true; + Colors::red(std::cerr); + std::cerr << *i << '/' << (root->size() - 1); + Colors::green(std::cerr); + std::cerr << " CHECKING: "; + Colors::normal(std::cerr); + std::cerr << curr; + Colors::green(std::cerr); + std::cerr << " [line: " << curr.line << "]\n"; + Colors::normal(std::cerr); + if (id == ASSERT_INVALID || id == ASSERT_MALFORMED || + id == ASSERT_UNLINKABLE) { + // a module invalidity test + Module wasm; + wasm.features = FeatureSet::All; + bool invalid = false; + std::unique_ptr builder; + try { + builder = std::unique_ptr( + new SExpressionWasmBuilder(wasm, *curr[1], IRProfile::Normal)); + } catch (const ParseException&) { + invalid = true; + } + if (!invalid) { + // maybe parsed ok, but otherwise incorrect + invalid = !WasmValidator().validate(wasm); + } + if (!invalid && id == ASSERT_UNLINKABLE) { + // validate "instantiating" the mdoule + auto reportUnknownImport = [&](Importable* import) { + std::cerr << "unknown import: " << import->module << '.' + << import->base << '\n'; + invalid = true; + }; + ModuleUtils::iterImportedGlobals(wasm, reportUnknownImport); + ModuleUtils::iterImportedFunctions(wasm, [&](Importable* import) { + if (import->module == SPECTEST && import->base.startsWith(PRINT)) { + // We can handle it. + } else { + reportUnknownImport(import); + } + }); + if (wasm.memory.imported()) { + reportUnknownImport(&wasm.memory); + } + if (wasm.table.imported()) { + reportUnknownImport(&wasm.table); + } + for (auto& segment : wasm.table.segments) { + for (auto name : segment.data) { + // spec tests consider it illegal to use spectest.print in a table + if (auto* import = wasm.getFunction(name)) { + if (import->imported() && import->module == SPECTEST && + import->base.startsWith(PRINT)) { + std::cerr << "cannot put spectest.print in table\n"; + invalid = true; + } + } + } + } + } + if (!invalid) { + Colors::red(std::cerr); + std::cerr << "[should have been invalid]\n"; + Colors::normal(std::cerr); + Fatal() << &wasm << '\n'; + } + } else if (id == INVOKE) { + assert(wasm); + Operation operation(curr, instance, *builder); + operation.operate(); + } else if (wasm) { // if no wasm, we skipped the module + // an invoke test + bool trapped = false; + WASM_UNUSED(trapped); + Literals result; + try { + Operation operation(*curr[1], instance, *builder); + result = operation.operate(); + } catch (const TrapException&) { + trapped = true; + } catch (const WasmException& e) { + std::cout << "[exception thrown: " << e.exn << "]" << std::endl; + trapped = true; + } + if (id == ASSERT_RETURN) { + assert(!trapped); + Literals expected; + if (curr.size() >= 3) { + expected = + getLiteralsFromConstExpression(builder->parseExpression(*curr[2])); + } + std::cerr << "seen " << result << ", expected " << expected << '\n'; + if (expected != result) { + Fatal() << "unexpected, should be identical\n"; + } + } + if (id == ASSERT_TRAP) { + assert(trapped); + } + } + *i += 1; + } +} + +// +// main +// + +int main(int argc, const char* argv[]) { + Name entry; + std::set skipped; + + Options options("wasm-shell", "Execute .wast files"); + options + .add("--entry", + "-e", + "Call the entry point after parsing the module", + Options::Arguments::One, + [&entry](Options*, const std::string& argument) { entry = argument; }) + .add("--skip", + "-s", + "Skip input on certain lines (comma-separated-list)", + Options::Arguments::One, + [&skipped](Options*, const std::string& argument) { + size_t i = 0; + while (i < argument.size()) { + auto ending = argument.find(',', i); + if (ending == std::string::npos) { + ending = argument.size(); + } + auto sub = argument.substr(i, ending - i); + skipped.insert(atoi(sub.c_str())); + i = ending + 1; + } + }) + .add_positional("INFILE", + Options::Arguments::One, + [](Options* o, const std::string& argument) { + o->extra["infile"] = argument; + }); + options.parse(argc, argv); + + auto input( + read_file>(options.extra["infile"], Flags::Text)); + + bool checked = false; + + try { + if (options.debug) { + std::cerr << "parsing text to s-expressions...\n"; + } + SExpressionParser parser(input.data()); + Element& root = *parser.root; + + // A .wast may have multiple modules, with some asserts after them + size_t i = 0; + while (i < root.size()) { + Element& curr = *root[i]; + if (skipped.count(curr.line) > 0) { + Colors::green(std::cerr); + std::cerr << "SKIPPING [line: " << curr.line << "]\n"; + Colors::normal(std::cerr); + i++; + continue; + } + IString id = curr[0]->str(); + if (id == MODULE) { + if (options.debug) { + std::cerr << "parsing s-expressions to wasm...\n"; + } + Colors::green(std::cerr); + std::cerr << "BUILDING MODULE [line: " << curr.line << "]\n"; + Colors::normal(std::cerr); + auto module = wasm::make_unique(); + auto builder = wasm::make_unique( + *module, *root[i], IRProfile::Normal); + auto moduleName = module->name; + builders[moduleName].swap(builder); + modules[moduleName].swap(module); + i++; + modules[moduleName]->features = FeatureSet::All; + bool valid = WasmValidator().validate(*modules[moduleName]); + if (!valid) { + WasmPrinter::printModule(modules[moduleName].get()); + Fatal() << "module failed to validate, see above"; + } + run_asserts(moduleName, + &i, + &checked, + modules[moduleName].get(), + &root, + builders[moduleName].get(), + entry); + } else { + run_asserts(Name(), &i, &checked, nullptr, &root, nullptr, entry); + } + } + } catch (ParseException& p) { + p.dump(std::cerr); + exit(1); + } + + if (checked) { + Colors::green(std::cerr); + Colors::bold(std::cerr); + std::cerr << "all checks passed.\n"; + Colors::normal(std::cerr); + } +} diff --git a/binaryen/src/tools/wasm2c-wrapper.h b/binaryen/src/tools/wasm2c-wrapper.h new file mode 100644 --- /dev/null +++ b/binaryen/src/tools/wasm2c-wrapper.h @@ -0,0 +1,207 @@ +/* + * Copyright 2020 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// Emit a C wrapper file that can run the wasm after it is compiled with +// wasm2c, useful for fuzzing. +// + +#include + +#include "wasm.h" + +namespace wasm { + +static std::string generateWasm2CWrapper(Module& wasm) { + // First, emit implementations of the wasm's imports so that the wasm2c code + // can call them. The names use wasm2c's name mangling. + std::string ret = R"( +#include +#include +#include + +#include "wasm-rt-impl.h" +#include "wasm.h" + +void _Z_fuzzingZ2DsupportZ_logZ2Di32Z_vi(u32 x) { + printf("[LoggingExternalInterface logging %d]\n", x); +} +void (*Z_fuzzingZ2DsupportZ_logZ2Di32Z_vi)(u32) = _Z_fuzzingZ2DsupportZ_logZ2Di32Z_vi; + +void _Z_fuzzingZ2DsupportZ_logZ2Di64Z_vj(u64 x) { + printf("[LoggingExternalInterface logging %" PRId64 "]\n", (int64_t)x); +} +void (*Z_fuzzingZ2DsupportZ_logZ2Di64Z_vj)(u64) = _Z_fuzzingZ2DsupportZ_logZ2Di64Z_vj; + +void _Z_fuzzingZ2DsupportZ_logZ2Di64Z_vii(u32 x, u32 y) { + printf("[LoggingExternalInterface logging %d %d]\n", x, y); +} +void (*Z_fuzzingZ2DsupportZ_logZ2Di64Z_vii)(u32, u32) = _Z_fuzzingZ2DsupportZ_logZ2Di64Z_vii; + +void _Z_fuzzingZ2DsupportZ_logZ2Df32Z_vf(f32 x) { + printf("[LoggingExternalInterface logging %.17e]\n", x); +} +void (*Z_fuzzingZ2DsupportZ_logZ2Df32Z_vf)(f32) = _Z_fuzzingZ2DsupportZ_logZ2Df32Z_vf; + +void _Z_fuzzingZ2DsupportZ_logZ2Df64Z_vd(f64 x) { + printf("[LoggingExternalInterface logging %.17le]\n", x); +} +void (*Z_fuzzingZ2DsupportZ_logZ2Df64Z_vd)(f64) = _Z_fuzzingZ2DsupportZ_logZ2Df64Z_vd; + +// Miscellaneous imports + +u32 tempRet0 = 0; + +void _Z_envZ_setTempRet0Z_vi(u32 x) { + tempRet0 = x; +} +void (*Z_envZ_setTempRet0Z_vi)(u32) = _Z_envZ_setTempRet0Z_vi; + +u32 _Z_envZ_getTempRet0Z_iv(void) { + return tempRet0; +} +u32 (*Z_envZ_getTempRet0Z_iv)(void) = _Z_envZ_getTempRet0Z_iv; + +// Main + +int main(int argc, char** argv) { + init(); + + // We go through each export and call it, in turn. Note that we use a loop + // so we can do all this with a single setjmp. A setjmp is needed to handle + // wasm traps, and emitting a single one helps compilation speed into wasm as + // compile times are O(size * num_setjmps). + for (size_t curr = 0;; curr++) { + )"; + if (wasm.getExportOrNull("hangLimitInitializer")) { + ret += R"( + // If present, call the hang limit initializer before each export. + (*Z_hangLimitInitializerZ_vv)(); +)"; + } + ret += R"( + // Prepare to call the export, so we can catch traps. + if (WASM_RT_SETJMP(g_jmp_buf) != 0) { + puts("exception!"); + } else { + // Call the proper export. + switch(curr) { +)"; + + // For each function export in the wasm, emit code to call it and log its + // result, similar to the other wrappers. + size_t functionExportIndex = 0; + + for (auto& exp : wasm.exports) { + if (exp->kind != ExternalKind::Function) { + continue; + } + + ret += " case " + std::to_string(functionExportIndex++) + ":\n"; + + auto* func = wasm.getFunction(exp->value); + + ret += std::string(" puts(\"[fuzz-exec] calling ") + + exp->name.str + "\");\n"; + auto result = func->sig.results; + + // Emit the call itself. + ret += " "; + if (result != Type::none) { + ret += std::string("printf(\"[fuzz-exec] note result: ") + exp->name.str + + " => "; + TODO_SINGLE_COMPOUND(result); + switch (result.getBasic()) { + case Type::i32: + ret += "%d\\n\", "; + break; + case Type::i64: + ret += "%\" PRId64 \"\\n\", (int64_t)"; + break; + case Type::f32: + ret += "%.17e\\n\", "; + break; + case Type::f64: + ret += "%.17le\\n\", "; + break; + default: + Fatal() << "unhandled wasm2c wrapper result type: " << result; + } + } + + // Emit the callee's name with wasm2c name mangling. + ret += std::string("(*Z_") + exp->name.str + "Z_"; + + auto wasm2cSignature = [](Type type) { + TODO_SINGLE_COMPOUND(type); + switch (type.getBasic()) { + case Type::none: + return 'v'; + case Type::i32: + return 'i'; + case Type::i64: + return 'j'; + case Type::f32: + return 'f'; + case Type::f64: + return 'd'; + default: + Fatal() << "unhandled wasm2c wrapper signature type: " << type; + } + }; + + ret += wasm2cSignature(result); + if (func->sig.params.isTuple()) { + for (const auto& param : func->sig.params) { + ret += wasm2cSignature(param); + } + } else { + ret += wasm2cSignature(func->sig.params); + } + ret += ")("; + + // Emit the parameters (all 0s, like the other wrappers). + bool first = true; + for (const auto& param : func->sig.params) { + WASM_UNUSED(param); + if (!first) { + ret += ", "; + } + ret += "0"; + first = false; + } + if (result != Type::none) { + ret += ")"; + } + ret += ");\n"; + + // Break from the big switch. + ret += " break;\n"; + } + + ret += R"( default: + return 0; // All done. + } + } + } + return 0; +} +)"; + + return ret; +} + +} // namespace wasm diff --git a/binaryen/src/tools/wasm2js.cpp b/binaryen/src/tools/wasm2js.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/tools/wasm2js.cpp @@ -0,0 +1,1005 @@ +/* + * Copyright 2015 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// wasm2js console tool +// + +#include "wasm2js.h" +#include "optimization-options.h" +#include "pass.h" +#include "support/colors.h" +#include "support/command-line.h" +#include "support/file.h" +#include "wasm-s-parser.h" + +using namespace cashew; +using namespace wasm; + +// helpers + +namespace { + +static void optimizeWasm(Module& wasm, PassOptions options) { + // Perform various optimizations that will be good for JS, but would not be + // great for wasm in general + struct OptimizeForJS : public WalkerPass> { + bool isFunctionParallel() override { return true; } + + Pass* create() override { return new OptimizeForJS; } + + void visitBinary(Binary* curr) { + // x - -c (where c is a constant) is larger than x + c, in js (but not + // necessarily in wasm, where LEBs prefer negatives). + if (curr->op == SubInt32) { + if (auto* c = curr->right->dynCast()) { + if (c->value.geti32() < 0) { + curr->op = AddInt32; + c->value = c->value.neg(); + } + } + } + } + }; + + PassRunner runner(&wasm, options); + OptimizeForJS().run(&runner, &wasm); +} + +template static void printJS(Ref ast, T& output) { + JSPrinter jser(true, true, ast); + jser.printAst(); + output << jser.buffer << '\n'; +} + +// Traversals + +struct TraverseInfo { + TraverseInfo() = default; + TraverseInfo(Ref node) : node(node) { + assert(node.get()); + if (node->isArray()) { + for (size_t i = 0; i < node->size(); i++) { + maybeAdd(node[i]); + } + } else if (node->isAssign()) { + auto assign = node->asAssign(); + maybeAdd(assign->target()); + maybeAdd(assign->value()); + } else if (node->isAssignName()) { + auto assign = node->asAssignName(); + maybeAdd(assign->value()); + } else { + // no children + } + } + Ref node; + bool scanned = false; + std::vector children; + +private: + void maybeAdd(Ref child) { + if (child.get()) { + children.push_back(child); + } + } +}; + +// Traverse, calling visit after the children +static void traversePrePost(Ref node, + std::function visitPre, + std::function visitPost) { + std::vector stack; + stack.push_back(TraverseInfo(node)); + while (!stack.empty()) { + TraverseInfo& back = stack.back(); + if (!back.scanned) { + back.scanned = true; + // This is the first time we see this. + visitPre(back.node); + for (auto child : back.children) { + stack.emplace_back(child); + } + continue; + } + // Time to post-visit the node itself + auto node = back.node; + stack.pop_back(); + visitPost(node); + } +} + +static void traversePost(Ref node, std::function visit) { + traversePrePost( + node, [](Ref node) {}, visit); +} + +static void replaceInPlace(Ref target, Ref value) { + assert(target->isArray() && value->isArray()); + target->setSize(value->size()); + for (size_t i = 0; i < value->size(); i++) { + target[i] = value[i]; + } +} + +static void replaceInPlaceIfPossible(Ref target, Ref value) { + if (target->isArray() && value->isArray()) { + replaceInPlace(target, value); + } +} + +static void optimizeJS(Ref ast, Wasm2JSBuilder::Flags flags) { + // Helpers + + auto isBinary = [](Ref node, IString op) { + return node->isArray() && !node->empty() && node[0] == BINARY && + node[1] == op; + }; + + auto isConstantBinary = [&](Ref node, IString op, int num) { + return isBinary(node, op) && node[3]->isNumber() && + node[3]->getNumber() == num; + }; + + auto isOrZero = [&](Ref node) { return isConstantBinary(node, OR, 0); }; + + auto isTrshiftZero = [&](Ref node) { + return isConstantBinary(node, TRSHIFT, 0); + }; + + auto isPlus = [](Ref node) { + return node->isArray() && !node->empty() && node[0] == UNARY_PREFIX && + node[1] == PLUS; + }; + + auto isFround = [](Ref node) { + return node->isArray() && !node->empty() && node[0] == cashew::CALL && + node[1] == MATH_FROUND; + }; + + auto isBitwise = [](Ref node) { + if (node->isArray() && !node->empty() && node[0] == BINARY) { + auto op = node[1]; + return op == OR || op == AND || op == XOR || op == RSHIFT || + op == TRSHIFT || op == LSHIFT; + } + return false; + }; + + auto isSignedBitwise = [](Ref node) { + if (node->isArray() && !node->empty() && node[0] == BINARY) { + auto op = node[1]; + return op == OR || op == AND || op == XOR || op == RSHIFT || op == LSHIFT; + } + return false; + }; + + auto isUnary = [](Ref node, IString op) { + return node->isArray() && !node->empty() && node[0] == UNARY_PREFIX && + node[1] == op; + }; + + auto isWhile = [](Ref node) { + return node->isArray() && !node->empty() && node[0] == WHILE; + }; + + auto isDo = [](Ref node) { + return node->isArray() && !node->empty() && node[0] == DO; + }; + + auto isIf = [](Ref node) { + return node->isArray() && !node->empty() && node[0] == IF; + }; + + auto removeOrZero = [&](Ref node) { + while (isOrZero(node)) { + node = node[2]; + } + return node; + }; + + auto removePlus = [&](Ref node) { + while (isPlus(node)) { + node = node[2]; + } + return node; + }; + + auto removePlusAndFround = [&](Ref node) { + while (1) { + if (isFround(node)) { + node = node[2][0]; + } else if (isPlus(node)) { + node = node[2]; + } else { + break; + } + } + return node; + }; + + auto getHeapFromAccess = [](Ref node) { return node[1]->getIString(); }; + + auto setHeapOnAccess = [](Ref node, IString heap) { + node[1] = ValueBuilder::makeName(heap); + }; + + auto isIntegerHeap = [](IString heap) { + return heap == HEAP8 || heap == HEAPU8 || heap == HEAP16 || + heap == HEAPU16 || heap == HEAP32 || heap == HEAPU32; + }; + + auto isFloatHeap = [](IString heap) { + return heap == HEAPF32 || heap == HEAPF64; + }; + + auto isHeapAccess = [&](Ref node) { + if (node->isArray() && !node->empty() && node[0] == SUB && + node[1]->isString()) { + auto heap = getHeapFromAccess(node); + return isIntegerHeap(heap) || isFloatHeap(heap); + } + return false; + }; + + // Optimize given that the expression is flowing into a boolean context + auto optimizeBoolean = [&](Ref node) { + // TODO: in some cases it may be possible to turn + // + // if (x | 0) + // + // into + // + // if (x) + // + // In general this is unsafe if e.g. x is -2147483648 + -2147483648 (which + // the | 0 turns into 0, but without it is a truthy value). + // + // Another issue is that in deterministic mode we care about corner cases + // that would trap in wasm, like an integer divide by zero: + // + // if ((1 / 0) | 0) => condition is Infinity | 0 = 0 which is falsey + // + // while + // + // if (1 / 0) => condition is Infinity which is truthy + // + // Thankfully this is not common, and does not occur on % (1 % 0 is a NaN + // which has the right truthiness), so we could perhaps do + // + // if (!(flags.deterministic && isBinary(node[2], DIV))) return node[2]; + // + // (but there is still the first issue). + return node; + }; + + // Optimizations + + // Pre-simplification + traversePost(ast, [&](Ref node) { + // x >> 0 => x | 0 + if (isConstantBinary(node, RSHIFT, 0)) { + node[1]->setString(OR); + } + }); + + traversePost(ast, [&](Ref node) { + if (isBitwise(node)) { + // x | 0 going into a bitwise op => skip the | 0 + node[2] = removeOrZero(node[2]); + node[3] = removeOrZero(node[3]); + // (x | 0 or similar) | 0 => (x | 0 or similar) + if (isOrZero(node)) { + if (isSignedBitwise(node[2])) { + replaceInPlace(node, node[2]); + } + } + if (isHeapAccess(node[2])) { + auto heap = getHeapFromAccess(node[2]); + IString replacementHeap; + // We can avoid a cast of a load by using the load to do it instead. + if (isOrZero(node)) { + if (isIntegerHeap(heap)) { + replacementHeap = heap; + } + } else if (isTrshiftZero(node)) { + // For signed or unsigned loads smaller than 32 bits, doing an | 0 + // was safe either way - they aren't in the range an | 0 can affect. + // For >>> 0 however, a negative value would change, so we still + // need the cast. + if (heap == HEAP32 || heap == HEAPU32) { + replacementHeap = HEAPU32; + } else if (heap == HEAPU16) { + replacementHeap = HEAPU16; + } else if (heap == HEAPU8) { + replacementHeap = HEAPU8; + } + } + if (!replacementHeap.isNull()) { + setHeapOnAccess(node[2], replacementHeap); + replaceInPlace(node, node[2]); + return; + } + // A load into an & may allow using a simpler heap, e.g. HEAPU8[..] & 1 + // (a load of a boolean) may be HEAP8[..] & 1. The signed heaps are more + // commonly used, so it compresses better, and also they seem to have + // better performance (perhaps since HEAPU32 is at risk of not being a + // smallint). + if (node[1] == AND) { + if (isConstantBinary(node, AND, 1)) { + if (heap == HEAPU8) { + setHeapOnAccess(node[2], HEAP8); + } else if (heap == HEAPU16) { + setHeapOnAccess(node[2], HEAP16); + } + } + } + } + // Pre-compute constant [op] constant, which the lowering can generate + // in loads etc. + if (node[2]->isNumber() && node[3]->isNumber()) { + int32_t left = node[2]->getNumber(); + int32_t right = node[3]->getNumber(); + if (node[1] == OR) { + node->setNumber(left | right); + } else if (node[1] == AND) { + node->setNumber(left & right); + } else if (node[1] == XOR) { + node->setNumber(left ^ right); + } else if (node[1] == LSHIFT) { + node->setNumber(left << (right & 31)); + } else if (node[1] == RSHIFT) { + node->setNumber(int32_t(left) >> int32_t(right & 31)); + } else if (node[1] == TRSHIFT) { + node->setNumber(uint32_t(left) >> uint32_t(right & 31)); + } + return; + } + } + // +(+x) => +x + else if (isPlus(node)) { + node[2] = removePlus(node[2]); + } + // +(+x) => +x + else if (isFround(node)) { + node[2] = removePlusAndFround(node[2]); + } else if (isUnary(node, L_NOT)) { + node[2] = optimizeBoolean(node[2]); + } + // Add/subtract can merge coercions up, except when a child is a division, + // which needs to be eagerly truncated to remove fractional results. + else if (isBinary(node, PLUS) || isBinary(node, MINUS)) { + auto left = node[2]; + auto right = node[3]; + if (isOrZero(left) && isOrZero(right) && !isBinary(left[2], DIV) && + !isBinary(right[2], DIV)) { + auto op = node[1]->getIString(); + // Add a coercion on top. + node[1]->setString(OR); + node[2] = left; + node[3] = ValueBuilder::makeNum(0); + // Add/subtract the inner uncoerced values. + left[1]->setString(op); + left[3] = right[2]; + } + } + // Assignment into a heap coerces. + else if (node->isAssign()) { + auto assign = node->asAssign(); + auto target = assign->target(); + if (isHeapAccess(target)) { + auto heap = getHeapFromAccess(target); + if (isIntegerHeap(heap)) { + if (heap == HEAP8 || heap == HEAPU8) { + while (isOrZero(assign->value()) || + isConstantBinary(assign->value(), AND, 255)) { + assign->value() = assign->value()[2]; + } + } else if (heap == HEAP16 || heap == HEAPU16) { + while (isOrZero(assign->value()) || + isConstantBinary(assign->value(), AND, 65535)) { + assign->value() = assign->value()[2]; + } + } else { + assert(heap == HEAP32 || heap == HEAPU32); + assign->value() = removeOrZero(assign->value()); + } + } else { + assert(isFloatHeap(heap)); + if (heap == HEAPF32) { + assign->value() = removePlusAndFround(assign->value()); + } else { + assign->value() = removePlus(assign->value()); + } + } + } + } else if (isWhile(node) || isDo(node) || isIf(node)) { + node[1] = optimizeBoolean(node[1]); + } + }); + + // Remove unnecessary break/continue labels, when the name is that of the + // highest target anyhow, which we would reach without the name. + + std::vector breakCapturers; + std::vector continueCapturers; + std::unordered_map + labelToValue; // maps the label to the loop/etc. + std::unordered_set labelled; // all things with a label on them. + Value INVALID; + traversePrePost( + ast, + [&](Ref node) { + if (node->isArray() && !node->empty()) { + if (node[0] == LABEL) { + auto label = node[1]->getIString(); + labelToValue[label] = node[2]; + labelled.insert(node[2].get()); + } else if (node[0] == WHILE || node[0] == DO || node[0] == FOR) { + breakCapturers.push_back(node); + continueCapturers.push_back(node); + } else if (node[0] == cashew::BLOCK) { + if (labelled.count(node.get())) { + // Cannot break to a block without the label. + breakCapturers.push_back(Ref(&INVALID)); + } + } else if (node[0] == SWITCH) { + breakCapturers.push_back(node); + } + } + }, + [&](Ref node) { + if (node->isArray() && !node->empty()) { + if (node[0] == LABEL) { + auto label = node[1]->getIString(); + labelToValue.erase(label); + labelled.erase(node[2].get()); + } else if (node[0] == WHILE || node[0] == DO || node[0] == FOR) { + breakCapturers.pop_back(); + continueCapturers.pop_back(); + } else if (node[0] == cashew::BLOCK) { + if (labelled.count(node.get())) { + breakCapturers.pop_back(); + } + } else if (node[0] == SWITCH) { + breakCapturers.pop_back(); + } else if (node[0] == BREAK || node[0] == CONTINUE) { + if (!node[1]->isNull()) { + auto label = node[1]->getIString(); + assert(labelToValue.count(label)); + auto& capturers = + node[0] == BREAK ? breakCapturers : continueCapturers; + assert(!capturers.empty()); + if (capturers.back() == labelToValue[label]) { + // Success, the break/continue goes exactly where we would if we + // didn't have the label! + node[1]->setNull(); + } + } + } + } + }); + + // Remove unnecessary block/loop labels. + + std::set usedLabelNames; + + traversePost(ast, [&](Ref node) { + if (node->isArray() && !node->empty()) { + if (node[0] == BREAK || node[0] == CONTINUE) { + if (!node[1]->isNull()) { + auto label = node[1]->getIString(); + usedLabelNames.insert(label); + } + } else if (node[0] == LABEL) { + auto label = node[1]->getIString(); + if (usedLabelNames.count(label)) { + // It's used; just erase it from the data structure. + usedLabelNames.erase(label); + } else { + // It's not used - get rid of it. + replaceInPlaceIfPossible(node, node[2]); + } + } + } + }); +} + +static void emitWasm(Module& wasm, + Output& output, + Wasm2JSBuilder::Flags flags, + PassOptions options, + Name name) { + if (options.optimizeLevel > 0) { + optimizeWasm(wasm, options); + } + Wasm2JSBuilder wasm2js(flags, options); + auto js = wasm2js.processWasm(&wasm, name); + if (options.optimizeLevel >= 2) { + optimizeJS(js, flags); + } + Wasm2JSGlue glue(wasm, output, flags, name); + glue.emitPre(); + printJS(js, output); + glue.emitPost(); +} + +class AssertionEmitter { +public: + AssertionEmitter(Element& root, + SExpressionWasmBuilder& sexpBuilder, + Output& out, + Wasm2JSBuilder::Flags flags, + const ToolOptions& options) + : root(root), sexpBuilder(sexpBuilder), out(out), flags(flags), + options(options) {} + + void emit(); + +private: + Element& root; + SExpressionWasmBuilder& sexpBuilder; + Output& out; + Wasm2JSBuilder::Flags flags; + ToolOptions options; + Module tempAllocationModule; + + Ref emitAssertReturnFunc(Builder& wasmBuilder, + Element& e, + Name testFuncName, + Name asmModule); + Ref emitAssertReturnNanFunc(Builder& wasmBuilder, + Element& e, + Name testFuncName, + Name asmModule); + Ref emitAssertTrapFunc(Builder& wasmBuilder, + Element& e, + Name testFuncName, + Name asmModule); + Ref emitInvokeFunc(Builder& wasmBuilder, + Element& e, + Name testFuncName, + Name asmModule); + bool isInvokeHandled(Element& e); + bool isAssertHandled(Element& e); + void fixCalls(Ref asmjs, Name asmModule); + + Ref processFunction(Function* func) { + Wasm2JSBuilder sub(flags, options.passOptions); + return sub.processStandaloneFunction(&tempAllocationModule, func); + } + + void emitFunction(Ref func) { + JSPrinter jser(true, true, func); + jser.printAst(); + out << jser.buffer << std::endl; + } +}; + +Ref AssertionEmitter::emitAssertReturnFunc(Builder& wasmBuilder, + Element& e, + Name testFuncName, + Name asmModule) { + Expression* actual = sexpBuilder.parseExpression(e[1]); + Expression* body = nullptr; + if (e.size() == 2) { + if (actual->type == Type::none) { + body = wasmBuilder.blockify(actual, wasmBuilder.makeConst(uint32_t(1))); + } else { + body = actual; + } + } else if (e.size() == 3) { + Expression* expected = sexpBuilder.parseExpression(e[2]); + Type resType = expected->type; + actual->type = resType; + TODO_SINGLE_COMPOUND(resType); + switch (resType.getBasic()) { + case Type::i32: + body = wasmBuilder.makeBinary(EqInt32, actual, expected); + break; + + case Type::i64: + body = wasmBuilder.makeCall( + "i64Equal", + {actual, + wasmBuilder.makeCall(WASM_FETCH_HIGH_BITS, {}, Type::i32), + expected}, + Type::i32); + break; + + case Type::f32: { + body = wasmBuilder.makeCall("f32Equal", {actual, expected}, Type::i32); + break; + } + case Type::f64: { + body = wasmBuilder.makeCall("f64Equal", {actual, expected}, Type::i32); + break; + } + + default: { + Fatal() << "Unhandled type in assert: " << resType; + } + } + } else { + assert(false && "Unexpected number of parameters in assert_return"); + } + std::unique_ptr testFunc( + wasmBuilder.makeFunction(testFuncName, + std::vector{}, + body->type, + std::vector{}, + body)); + Ref jsFunc = processFunction(testFunc.get()); + fixCalls(jsFunc, asmModule); + emitFunction(jsFunc); + return jsFunc; +} + +Ref AssertionEmitter::emitAssertReturnNanFunc(Builder& wasmBuilder, + Element& e, + Name testFuncName, + Name asmModule) { + Expression* actual = sexpBuilder.parseExpression(e[1]); + Expression* body = wasmBuilder.makeCall("isNaN", {actual}, Type::i32); + std::unique_ptr testFunc( + wasmBuilder.makeFunction(testFuncName, + std::vector{}, + body->type, + std::vector{}, + body)); + Ref jsFunc = processFunction(testFunc.get()); + fixCalls(jsFunc, asmModule); + emitFunction(jsFunc); + return jsFunc; +} + +Ref AssertionEmitter::emitAssertTrapFunc(Builder& wasmBuilder, + Element& e, + Name testFuncName, + Name asmModule) { + Name innerFuncName("f"); + Expression* expr = sexpBuilder.parseExpression(e[1]); + std::unique_ptr exprFunc( + wasmBuilder.makeFunction(innerFuncName, + std::vector{}, + expr->type, + std::vector{}, + expr)); + IString expectedErr = e[2]->str(); + Ref innerFunc = processFunction(exprFunc.get()); + fixCalls(innerFunc, asmModule); + Ref outerFunc = ValueBuilder::makeFunction(testFuncName); + outerFunc[3]->push_back(innerFunc); + Ref tryBlock = ValueBuilder::makeBlock(); + ValueBuilder::appendToBlock(tryBlock, ValueBuilder::makeCall(innerFuncName)); + Ref catchBlock = ValueBuilder::makeBlock(); + ValueBuilder::appendToBlock( + catchBlock, + ValueBuilder::makeReturn(ValueBuilder::makeCall( + ValueBuilder::makeDot(ValueBuilder::makeName(IString("e")), + ValueBuilder::makeName(IString("message")), + ValueBuilder::makeName(IString("includes"))), + ValueBuilder::makeString(expectedErr)))); + outerFunc[3]->push_back(ValueBuilder::makeTry( + tryBlock, ValueBuilder::makeName((IString("e"))), catchBlock)); + outerFunc[3]->push_back(ValueBuilder::makeReturn(ValueBuilder::makeInt(0))); + emitFunction(outerFunc); + return outerFunc; +} + +Ref AssertionEmitter::emitInvokeFunc(Builder& wasmBuilder, + Element& e, + Name testFuncName, + Name asmModule) { + Expression* body = sexpBuilder.parseExpression(e); + std::unique_ptr testFunc( + wasmBuilder.makeFunction(testFuncName, + std::vector{}, + body->type, + std::vector{}, + body)); + Ref jsFunc = processFunction(testFunc.get()); + fixCalls(jsFunc, asmModule); + emitFunction(jsFunc); + return jsFunc; +} + +bool AssertionEmitter::isInvokeHandled(Element& e) { + return e.isList() && e.size() >= 2 && e[0]->isStr() && + e[0]->str() == Name("invoke"); +} + +bool AssertionEmitter::isAssertHandled(Element& e) { + return e.isList() && e.size() >= 2 && e[0]->isStr() && + (e[0]->str() == Name("assert_return") || + e[0]->str() == Name("assert_return_nan") || + (flags.pedantic && e[0]->str() == Name("assert_trap"))) && + e[1]->isList() && e[1]->size() >= 2 && (*e[1])[0]->isStr() && + (*e[1])[0]->str() == Name("invoke"); +} + +void AssertionEmitter::fixCalls(Ref asmjs, Name asmModule) { + if (asmjs->isArray()) { + ArrayStorage& arr = asmjs->getArray(); + for (Ref& r : arr) { + fixCalls(r, asmModule); + } + if (arr.size() > 0 && arr[0]->isString() && + arr[0]->getIString() == cashew::CALL) { + assert(arr.size() >= 2); + if (arr[1]->getIString() == "f32Equal" || + arr[1]->getIString() == "f64Equal" || + arr[1]->getIString() == "i64Equal" || + arr[1]->getIString() == "isNaN") { + // ... + } else if (arr[1]->getIString() == "Math_fround") { + arr[1]->setString("Math.fround"); + } else { + Ref fixed = ValueBuilder::makeDot(ValueBuilder::makeName(asmModule), + arr[1]->getIString()); + arr[1]->setArray(fixed->getArray()); + } + } + } + + if (asmjs->isAssign()) { + fixCalls(asmjs->asAssign()->target(), asmModule); + fixCalls(asmjs->asAssign()->value(), asmModule); + } + if (asmjs->isAssignName()) { + fixCalls(asmjs->asAssignName()->value(), asmModule); + } +} + +void AssertionEmitter::emit() { + // TODO: nan and infinity shouldn't be needed once literal asm.js code isn't + // generated + out << R"( + var nan = NaN; + var infinity = Infinity; + )"; + + // When equating floating point values in spec tests we want to use bitwise + // equality like wasm does. Unfortunately though NaN makes this tricky. JS + // implementations like Spidermonkey and JSC will canonicalize NaN loads from + // `Float32Array`, but V8 will not. This means that NaN representations are + // kind of all over the place and difficult to bitwise equate. + // + // To work around this problem we just use a small shim which considers all + // NaN representations equivalent and otherwise tests for bitwise equality. + out << R"( + function f32Equal(a, b) { + var i = new Int32Array(1); + var f = new Float32Array(i.buffer); + f[0] = a; + var ai = f[0]; + f[0] = b; + var bi = f[0]; + + return (isNaN(a) && isNaN(b)) || a == b; + } + + function f64Equal(a, b) { + var i = new Int32Array(2); + var f = new Float64Array(i.buffer); + f[0] = a; + var ai1 = i[0]; + var ai2 = i[1]; + f[0] = b; + var bi1 = i[0]; + var bi2 = i[1]; + + return (isNaN(a) && isNaN(b)) || (ai1 == bi1 && ai2 == bi2); + } + + function i64Equal(actual_lo, actual_hi, expected_lo, expected_hi) { + return (actual_lo | 0) == (expected_lo | 0) && (actual_hi | 0) == (expected_hi | 0); + } + )"; + + Builder wasmBuilder(sexpBuilder.getModule()); + Name asmModule = std::string("ret") + ASM_FUNC.str; + for (size_t i = 0; i < root.size(); ++i) { + Element& e = *root[i]; + if (e.isList() && e.size() >= 1 && e[0]->isStr() && + e[0]->str() == Name("module")) { + std::stringstream funcNameS; + funcNameS << ASM_FUNC.c_str() << i; + std::stringstream moduleNameS; + moduleNameS << "ret" << ASM_FUNC.c_str() << i; + Name funcName(funcNameS.str().c_str()); + asmModule = Name(moduleNameS.str().c_str()); + Module wasm; + options.applyFeatures(wasm); + SExpressionWasmBuilder builder(wasm, e, options.profile); + emitWasm(wasm, out, flags, options.passOptions, funcName); + continue; + } + if (!isInvokeHandled(e) && !isAssertHandled(e)) { + std::cerr << "skipping " << e << std::endl; + continue; + } + Name testFuncName(IString(("check" + std::to_string(i)).c_str(), false)); + bool isInvoke = (e[0]->str() == Name("invoke")); + bool isReturn = (e[0]->str() == Name("assert_return")); + bool isReturnNan = (e[0]->str() == Name("assert_return_nan")); + Element* assertOp; + // An assertion of an invoke has the invoke inside the assert. + if (isAssertHandled(e)) { + assertOp = e[1]; + } else { + assertOp = &e; + } + // Replace "invoke" with "call" + (*assertOp)[0]->setString(IString("call"), false, false); + // Need to claim dollared to get string as function target + (*assertOp)[1]->setString((*assertOp)[1]->str(), /*dollared=*/true, false); + if (isInvoke) { + emitInvokeFunc(wasmBuilder, e, testFuncName, asmModule); + out << testFuncName.str << "();\n"; + continue; + } + // Otherwise, this is some form of assertion. + if (isReturn) { + emitAssertReturnFunc(wasmBuilder, e, testFuncName, asmModule); + } else if (isReturnNan) { + emitAssertReturnNanFunc(wasmBuilder, e, testFuncName, asmModule); + } else { + emitAssertTrapFunc(wasmBuilder, e, testFuncName, asmModule); + } + + out << "if (!" << testFuncName.str << "()) throw 'assertion failed: " << e + << "';\n"; + } +} + +} // anonymous namespace + +// Main + +int main(int argc, const char* argv[]) { + Wasm2JSBuilder::Flags flags; + OptimizationOptions options("wasm2js", + "Transform .wasm/.wat files to asm.js"); + options + .add("--output", + "-o", + "Output file (stdout if not specified)", + Options::Arguments::One, + [](Options* o, const std::string& argument) { + o->extra["output"] = argument; + Colors::setEnabled(false); + }) + .add("--allow-asserts", + "", + "Allow compilation of .wast testing asserts", + Options::Arguments::Zero, + [&](Options* o, const std::string& argument) { + flags.allowAsserts = true; + o->extra["asserts"] = "1"; + }) + .add( + "--pedantic", + "", + "Emulate WebAssembly trapping behavior", + Options::Arguments::Zero, + [&](Options* o, const std::string& argument) { flags.pedantic = true; }) + .add( + "--emscripten", + "", + "Emulate the glue in emscripten-compatible form (and not ES6 module " + "form)", + Options::Arguments::Zero, + [&](Options* o, const std::string& argument) { flags.emscripten = true; }) + .add( + "--deterministic", + "", + "Replace WebAssembly trapping behavior deterministically " + "(the default is to not care about what would trap in wasm, like a load " + "out of bounds or integer divide by zero; with this flag, we try to be " + "deterministic at least in what happens, which might or might not be " + "to trap like wasm, but at least should not vary)", + Options::Arguments::Zero, + [&](Options* o, const std::string& argument) { + flags.deterministic = true; + }) + .add( + "--symbols-file", + "", + "Emit a symbols file that maps function indexes to their original names", + Options::Arguments::One, + [&](Options* o, const std::string& argument) { + flags.symbolsFile = argument; + }) + .add_positional("INFILE", + Options::Arguments::One, + [](Options* o, const std::string& argument) { + o->extra["infile"] = argument; + }); + options.parse(argc, argv); + if (options.debug) { + flags.debug = true; + } + + Element* root = nullptr; + Module wasm; + options.applyFeatures(wasm); + Ref js; + std::unique_ptr sexprParser; + std::unique_ptr sexprBuilder; + + auto& input = options.extra["infile"]; + std::string suffix(".wasm"); + bool binaryInput = + input.size() >= suffix.size() && + input.compare(input.size() - suffix.size(), suffix.size(), suffix) == 0; + + try { + // If the input filename ends in `.wasm`, then parse it in binary form, + // otherwise assume it's a `*.wat` file and go from there. + // + // Note that we're not using the built-in `ModuleReader` which will also do + // similar logic here because when testing JS files we use the + // `--allow-asserts` flag which means we need to parse the extra + // s-expressions that come at the end of the `*.wast` file after the module + // is defined. + if (binaryInput) { + ModuleReader reader; + reader.read(input, wasm, ""); + } else { + auto input( + read_file>(options.extra["infile"], Flags::Text)); + if (options.debug) { + std::cerr << "s-parsing..." << std::endl; + } + sexprParser = make_unique(input.data()); + root = sexprParser->root; + + if (options.debug) { + std::cerr << "w-parsing..." << std::endl; + } + sexprBuilder = + make_unique(wasm, *(*root)[0], options.profile); + } + } catch (ParseException& p) { + p.dump(std::cerr); + Fatal() << "error in parsing input"; + } catch (std::bad_alloc&) { + Fatal() << "error in building module, std::bad_alloc (possibly invalid " + "request for silly amounts of memory)"; + } + + if (options.passOptions.validate) { + if (!WasmValidator().validate(wasm)) { + WasmPrinter::printModule(&wasm); + Fatal() << "error in validating input"; + } + } + + if (options.debug) { + std::cerr << "j-printing..." << std::endl; + } + Output output(options.extra["output"], Flags::Text); + if (!binaryInput && options.extra["asserts"] == "1") { + AssertionEmitter(*root, *sexprBuilder, output, flags, options).emit(); + } else { + emitWasm(wasm, output, flags, options.passOptions, "asmFunc"); + } + + if (options.debug) { + std::cerr << "done." << std::endl; + } +} diff --git a/binaryen/src/wasm-binary.h b/binaryen/src/wasm-binary.h new file mode 100644 --- /dev/null +++ b/binaryen/src/wasm-binary.h @@ -0,0 +1,1533 @@ +/* + * Copyright 2015 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// Parses and emits WebAssembly binary code +// + +#ifndef wasm_wasm_binary_h +#define wasm_wasm_binary_h + +#include +#include +#include + +#include "asm_v_wasm.h" +#include "asmjs/shared-constants.h" +#include "ir/import-utils.h" +#include "ir/module-utils.h" +#include "parsing.h" +#include "support/debug.h" +#include "wasm-builder.h" +#include "wasm-traversal.h" +#include "wasm-validator.h" +#include "wasm.h" + +#define DEBUG_TYPE "binary" + +namespace wasm { + +enum { + // the maximum amount of bytes we emit per LEB + MaxLEB32Bytes = 5, +}; + +// wasm VMs on the web have decided to impose some limits on what they +// accept +enum WebLimitations : uint32_t { + MaxDataSegments = 100 * 1000, + MaxFunctionBodySize = 128 * 1024, + MaxFunctionLocals = 50 * 1000 +}; + +template struct LEB { + static_assert(sizeof(MiniT) == 1, "MiniT must be a byte"); + + T value; + + LEB() = default; + LEB(T value) : value(value) {} + + bool hasMore(T temp, MiniT byte) { + // for signed, we must ensure the last bit has the right sign, as it will + // zero extend + return std::is_signed::value + ? (temp != 0 && temp != T(-1)) || (value >= 0 && (byte & 64)) || + (value < 0 && !(byte & 64)) + : (temp != 0); + } + + void write(std::vector* out) { + T temp = value; + bool more; + do { + uint8_t byte = temp & 127; + temp >>= 7; + more = hasMore(temp, byte); + if (more) { + byte = byte | 128; + } + out->push_back(byte); + } while (more); + } + + // @minimum: a minimum number of bytes to write, padding as necessary + // returns the number of bytes written + size_t writeAt(std::vector* out, size_t at, size_t minimum = 0) { + T temp = value; + size_t offset = 0; + bool more; + do { + uint8_t byte = temp & 127; + temp >>= 7; + more = hasMore(temp, byte) || offset + 1 < minimum; + if (more) { + byte = byte | 128; + } + (*out)[at + offset] = byte; + offset++; + } while (more); + return offset; + } + + LEB& read(std::function get) { + value = 0; + T shift = 0; + MiniT byte; + while (1) { + byte = get(); + bool last = !(byte & 128); + T payload = byte & 127; + typedef typename std::make_unsigned::type mask_type; + auto shift_mask = 0 == shift + ? ~mask_type(0) + : ((mask_type(1) << (sizeof(T) * 8 - shift)) - 1u); + T significant_payload = payload & shift_mask; + if (significant_payload != payload) { + if (!(std::is_signed::value && last)) { + throw ParseException("LEB dropped bits only valid for signed LEB"); + } + } + value |= significant_payload << shift; + if (last) { + break; + } + shift += 7; + if (size_t(shift) >= sizeof(T) * 8) { + throw ParseException("LEB overflow"); + } + } + // If signed LEB, then we might need to sign-extend. (compile should + // optimize this out if not needed). + if (std::is_signed::value) { + shift += 7; + if ((byte & 64) && size_t(shift) < 8 * sizeof(T)) { + size_t sext_bits = 8 * sizeof(T) - size_t(shift); + value <<= sext_bits; + value >>= sext_bits; + if (value >= 0) { + throw ParseException( + " LEBsign-extend should produce a negative value"); + } + } + } + return *this; + } +}; + +typedef LEB U32LEB; +typedef LEB U64LEB; +typedef LEB S32LEB; +typedef LEB S64LEB; + +// +// We mostly stream into a buffer as we create the binary format, however, +// sometimes we need to backtrack and write to a location behind us - wasm +// is optimized for reading, not writing. +// +class BufferWithRandomAccess : public std::vector { +public: + BufferWithRandomAccess() = default; + + BufferWithRandomAccess& operator<<(int8_t x) { + BYN_TRACE("writeInt8: " << (int)(uint8_t)x << " (at " << size() << ")\n"); + push_back(x); + return *this; + } + BufferWithRandomAccess& operator<<(int16_t x) { + BYN_TRACE("writeInt16: " << x << " (at " << size() << ")\n"); + push_back(x & 0xff); + push_back(x >> 8); + return *this; + } + BufferWithRandomAccess& operator<<(int32_t x) { + BYN_TRACE("writeInt32: " << x << " (at " << size() << ")\n"); + push_back(x & 0xff); + x >>= 8; + push_back(x & 0xff); + x >>= 8; + push_back(x & 0xff); + x >>= 8; + push_back(x & 0xff); + return *this; + } + BufferWithRandomAccess& operator<<(int64_t x) { + BYN_TRACE("writeInt64: " << x << " (at " << size() << ")\n"); + push_back(x & 0xff); + x >>= 8; + push_back(x & 0xff); + x >>= 8; + push_back(x & 0xff); + x >>= 8; + push_back(x & 0xff); + x >>= 8; + push_back(x & 0xff); + x >>= 8; + push_back(x & 0xff); + x >>= 8; + push_back(x & 0xff); + x >>= 8; + push_back(x & 0xff); + return *this; + } + BufferWithRandomAccess& operator<<(U32LEB x) { + size_t before = -1; + WASM_UNUSED(before); + BYN_DEBUG(before = size(); std::cerr << "writeU32LEB: " << x.value + << " (at " << before << ")" + << std::endl;); + x.write(this); + BYN_DEBUG(for (size_t i = before; i < size(); i++) { + std::cerr << " " << (int)at(i) << " (at " << i << ")\n"; + }); + return *this; + } + BufferWithRandomAccess& operator<<(U64LEB x) { + size_t before = -1; + WASM_UNUSED(before); + BYN_DEBUG(before = size(); std::cerr << "writeU64LEB: " << x.value + << " (at " << before << ")" + << std::endl;); + x.write(this); + BYN_DEBUG(for (size_t i = before; i < size(); i++) { + std::cerr << " " << (int)at(i) << " (at " << i << ")\n"; + }); + return *this; + } + BufferWithRandomAccess& operator<<(S32LEB x) { + size_t before = -1; + WASM_UNUSED(before); + BYN_DEBUG(before = size(); std::cerr << "writeS32LEB: " << x.value + << " (at " << before << ")" + << std::endl;); + x.write(this); + BYN_DEBUG(for (size_t i = before; i < size(); i++) { + std::cerr << " " << (int)at(i) << " (at " << i << ")\n"; + }); + return *this; + } + BufferWithRandomAccess& operator<<(S64LEB x) { + size_t before = -1; + WASM_UNUSED(before); + BYN_DEBUG(before = size(); std::cerr << "writeS64LEB: " << x.value + << " (at " << before << ")" + << std::endl;); + x.write(this); + BYN_DEBUG(for (size_t i = before; i < size(); i++) { + std::cerr << " " << (int)at(i) << " (at " << i << ")\n"; + }); + return *this; + } + + BufferWithRandomAccess& operator<<(uint8_t x) { return *this << (int8_t)x; } + BufferWithRandomAccess& operator<<(uint16_t x) { return *this << (int16_t)x; } + BufferWithRandomAccess& operator<<(uint32_t x) { return *this << (int32_t)x; } + BufferWithRandomAccess& operator<<(uint64_t x) { return *this << (int64_t)x; } + + BufferWithRandomAccess& operator<<(float x) { + BYN_TRACE("writeFloat32: " << x << " (at " << size() << ")\n"); + return *this << Literal(x).reinterpreti32(); + } + BufferWithRandomAccess& operator<<(double x) { + BYN_TRACE("writeFloat64: " << x << " (at " << size() << ")\n"); + return *this << Literal(x).reinterpreti64(); + } + + void writeAt(size_t i, uint16_t x) { + BYN_TRACE("backpatchInt16: " << x << " (at " << i << ")\n"); + (*this)[i] = x & 0xff; + (*this)[i + 1] = x >> 8; + } + void writeAt(size_t i, uint32_t x) { + BYN_TRACE("backpatchInt32: " << x << " (at " << i << ")\n"); + (*this)[i] = x & 0xff; + x >>= 8; + (*this)[i + 1] = x & 0xff; + x >>= 8; + (*this)[i + 2] = x & 0xff; + x >>= 8; + (*this)[i + 3] = x & 0xff; + } + + // writes out an LEB to an arbitrary location. this writes the LEB as a full + // 5 bytes, the fixed amount that can easily be set aside ahead of time + void writeAtFullFixedSize(size_t i, U32LEB x) { + BYN_TRACE("backpatchU32LEB: " << x.value << " (at " << i << ")\n"); + // fill all 5 bytes, we have to do this when backpatching + x.writeAt(this, i, MaxLEB32Bytes); + } + // writes out an LEB of normal size + // returns how many bytes were written + size_t writeAt(size_t i, U32LEB x) { + BYN_TRACE("writeAtU32LEB: " << x.value << " (at " << i << ")\n"); + return x.writeAt(this, i); + } + + template void writeTo(T& o) { + for (auto c : *this) { + o << c; + } + } + + std::vector getAsChars() { + std::vector ret; + ret.resize(size()); + std::copy(begin(), end(), ret.begin()); + return ret; + } +}; + +namespace BinaryConsts { + +enum Meta { Magic = 0x6d736100, Version = 0x01 }; + +enum Section { + User = 0, + Type = 1, + Import = 2, + Function = 3, + Table = 4, + Memory = 5, + Global = 6, + Export = 7, + Start = 8, + Element = 9, + Code = 10, + Data = 11, + DataCount = 12, + Event = 13 +}; + +enum SegmentFlag { IsPassive = 0x01, HasMemIndex = 0x02 }; + +enum EncodedType { + // value_type + i32 = -0x1, // 0x7f + i64 = -0x2, // 0x7e + f32 = -0x3, // 0x7d + f64 = -0x4, // 0x7c + v128 = -0x5, // 0x7b + // function reference type + funcref = -0x10, // 0x70 + // opaque host reference type + externref = -0x11, // 0x6f + // any reference type + anyref = -0x12, // 0x6e + // comparable reference type + eqref = -0x13, // 0x6d + // integer reference type + i31ref = -0x16, // 0x6a + // exception reference type + exnref = -0x18, // 0x68 + // func_type form + Func = -0x20, // 0x60 + // block_type + Empty = -0x40 // 0x40 +}; + +enum EncodedHeapType { + func = -0x10, // 0x70 + extern_ = -0x11, // 0x6f + any = -0x12, // 0x6e + eq = -0x13, // 0x6d + i31 = -0x17, // 0x69, != i31ref + exn = -0x18, // 0x68 +}; + +namespace UserSections { +extern const char* Name; +extern const char* SourceMapUrl; +extern const char* Dylink; +extern const char* Linking; +extern const char* Producers; +extern const char* TargetFeatures; + +extern const char* AtomicsFeature; +extern const char* BulkMemoryFeature; +extern const char* ExceptionHandlingFeature; +extern const char* MutableGlobalsFeature; +extern const char* TruncSatFeature; +extern const char* SignExtFeature; +extern const char* SIMD128Feature; +extern const char* ExceptionHandlingFeature; +extern const char* TailCallFeature; +extern const char* ReferenceTypesFeature; +extern const char* MultivalueFeature; +extern const char* GCFeature; +extern const char* Memory64Feature; + +enum Subsection { + NameModule = 0, + NameFunction = 1, + NameLocal = 2, + // see: https://github.com/WebAssembly/extended-name-section + NameLabel = 3, + NameType = 4, + NameTable = 5, + NameMemory = 6, + NameGlobal = 7, + NameElem = 8, + NameData = 9 +}; + +} // namespace UserSections + +enum ASTNodes { + Unreachable = 0x00, + Nop = 0x01, + Block = 0x02, + Loop = 0x03, + If = 0x04, + Else = 0x05, + + End = 0x0b, + Br = 0x0c, + BrIf = 0x0d, + BrTable = 0x0e, + Return = 0x0f, + + CallFunction = 0x10, + CallIndirect = 0x11, + RetCallFunction = 0x12, + RetCallIndirect = 0x13, + + Drop = 0x1a, + Select = 0x1b, + SelectWithType = 0x1c, // added in reference types proposal + + LocalGet = 0x20, + LocalSet = 0x21, + LocalTee = 0x22, + GlobalGet = 0x23, + GlobalSet = 0x24, + + I32LoadMem = 0x28, + I64LoadMem = 0x29, + F32LoadMem = 0x2a, + F64LoadMem = 0x2b, + + I32LoadMem8S = 0x2c, + I32LoadMem8U = 0x2d, + I32LoadMem16S = 0x2e, + I32LoadMem16U = 0x2f, + I64LoadMem8S = 0x30, + I64LoadMem8U = 0x31, + I64LoadMem16S = 0x32, + I64LoadMem16U = 0x33, + I64LoadMem32S = 0x34, + I64LoadMem32U = 0x35, + + I32StoreMem = 0x36, + I64StoreMem = 0x37, + F32StoreMem = 0x38, + F64StoreMem = 0x39, + + I32StoreMem8 = 0x3a, + I32StoreMem16 = 0x3b, + I64StoreMem8 = 0x3c, + I64StoreMem16 = 0x3d, + I64StoreMem32 = 0x3e, + + MemorySize = 0x3f, + MemoryGrow = 0x40, + + I32Const = 0x41, + I64Const = 0x42, + F32Const = 0x43, + F64Const = 0x44, + + I32EqZ = 0x45, + I32Eq = 0x46, + I32Ne = 0x47, + I32LtS = 0x48, + I32LtU = 0x49, + I32GtS = 0x4a, + I32GtU = 0x4b, + I32LeS = 0x4c, + I32LeU = 0x4d, + I32GeS = 0x4e, + I32GeU = 0x4f, + I64EqZ = 0x50, + I64Eq = 0x51, + I64Ne = 0x52, + I64LtS = 0x53, + I64LtU = 0x54, + I64GtS = 0x55, + I64GtU = 0x56, + I64LeS = 0x57, + I64LeU = 0x58, + I64GeS = 0x59, + I64GeU = 0x5a, + F32Eq = 0x5b, + F32Ne = 0x5c, + F32Lt = 0x5d, + F32Gt = 0x5e, + F32Le = 0x5f, + F32Ge = 0x60, + F64Eq = 0x61, + F64Ne = 0x62, + F64Lt = 0x63, + F64Gt = 0x64, + F64Le = 0x65, + F64Ge = 0x66, + + I32Clz = 0x67, + I32Ctz = 0x68, + I32Popcnt = 0x69, + I32Add = 0x6a, + I32Sub = 0x6b, + I32Mul = 0x6c, + I32DivS = 0x6d, + I32DivU = 0x6e, + I32RemS = 0x6f, + I32RemU = 0x70, + I32And = 0x71, + I32Or = 0x72, + I32Xor = 0x73, + I32Shl = 0x74, + I32ShrS = 0x75, + I32ShrU = 0x76, + I32RotL = 0x77, + I32RotR = 0x78, + + I64Clz = 0x79, + I64Ctz = 0x7a, + I64Popcnt = 0x7b, + I64Add = 0x7c, + I64Sub = 0x7d, + I64Mul = 0x7e, + I64DivS = 0x7f, + I64DivU = 0x80, + I64RemS = 0x81, + I64RemU = 0x82, + I64And = 0x83, + I64Or = 0x84, + I64Xor = 0x85, + I64Shl = 0x86, + I64ShrS = 0x87, + I64ShrU = 0x88, + I64RotL = 0x89, + I64RotR = 0x8a, + + F32Abs = 0x8b, + F32Neg = 0x8c, + F32Ceil = 0x8d, + F32Floor = 0x8e, + F32Trunc = 0x8f, + F32NearestInt = 0x90, + F32Sqrt = 0x91, + F32Add = 0x92, + F32Sub = 0x93, + F32Mul = 0x94, + F32Div = 0x95, + F32Min = 0x96, + F32Max = 0x97, + F32CopySign = 0x98, + + F64Abs = 0x99, + F64Neg = 0x9a, + F64Ceil = 0x9b, + F64Floor = 0x9c, + F64Trunc = 0x9d, + F64NearestInt = 0x9e, + F64Sqrt = 0x9f, + F64Add = 0xa0, + F64Sub = 0xa1, + F64Mul = 0xa2, + F64Div = 0xa3, + F64Min = 0xa4, + F64Max = 0xa5, + F64CopySign = 0xa6, + + I32WrapI64 = 0xa7, + I32STruncF32 = 0xa8, + I32UTruncF32 = 0xa9, + I32STruncF64 = 0xaa, + I32UTruncF64 = 0xab, + I64SExtendI32 = 0xac, + I64UExtendI32 = 0xad, + I64STruncF32 = 0xae, + I64UTruncF32 = 0xaf, + I64STruncF64 = 0xb0, + I64UTruncF64 = 0xb1, + F32SConvertI32 = 0xb2, + F32UConvertI32 = 0xb3, + F32SConvertI64 = 0xb4, + F32UConvertI64 = 0xb5, + F32DemoteI64 = 0xb6, + F64SConvertI32 = 0xb7, + F64UConvertI32 = 0xb8, + F64SConvertI64 = 0xb9, + F64UConvertI64 = 0xba, + F64PromoteF32 = 0xbb, + + I32ReinterpretF32 = 0xbc, + I64ReinterpretF64 = 0xbd, + F32ReinterpretI32 = 0xbe, + F64ReinterpretI64 = 0xbf, + + I32ExtendS8 = 0xc0, + I32ExtendS16 = 0xc1, + I64ExtendS8 = 0xc2, + I64ExtendS16 = 0xc3, + I64ExtendS32 = 0xc4, + + // prefixes + + GCPrefix = 0xfb, + MiscPrefix = 0xfc, + SIMDPrefix = 0xfd, + AtomicPrefix = 0xfe, + + // atomic opcodes + + AtomicNotify = 0x00, + I32AtomicWait = 0x01, + I64AtomicWait = 0x02, + AtomicFence = 0x03, + + I32AtomicLoad = 0x10, + I64AtomicLoad = 0x11, + I32AtomicLoad8U = 0x12, + I32AtomicLoad16U = 0x13, + I64AtomicLoad8U = 0x14, + I64AtomicLoad16U = 0x15, + I64AtomicLoad32U = 0x16, + I32AtomicStore = 0x17, + I64AtomicStore = 0x18, + I32AtomicStore8 = 0x19, + I32AtomicStore16 = 0x1a, + I64AtomicStore8 = 0x1b, + I64AtomicStore16 = 0x1c, + I64AtomicStore32 = 0x1d, + + AtomicRMWOps_Begin = 0x1e, + I32AtomicRMWAdd = 0x1e, + I64AtomicRMWAdd = 0x1f, + I32AtomicRMWAdd8U = 0x20, + I32AtomicRMWAdd16U = 0x21, + I64AtomicRMWAdd8U = 0x22, + I64AtomicRMWAdd16U = 0x23, + I64AtomicRMWAdd32U = 0x24, + I32AtomicRMWSub = 0x25, + I64AtomicRMWSub = 0x26, + I32AtomicRMWSub8U = 0x27, + I32AtomicRMWSub16U = 0x28, + I64AtomicRMWSub8U = 0x29, + I64AtomicRMWSub16U = 0x2a, + I64AtomicRMWSub32U = 0x2b, + I32AtomicRMWAnd = 0x2c, + I64AtomicRMWAnd = 0x2d, + I32AtomicRMWAnd8U = 0x2e, + I32AtomicRMWAnd16U = 0x2f, + I64AtomicRMWAnd8U = 0x30, + I64AtomicRMWAnd16U = 0x31, + I64AtomicRMWAnd32U = 0x32, + I32AtomicRMWOr = 0x33, + I64AtomicRMWOr = 0x34, + I32AtomicRMWOr8U = 0x35, + I32AtomicRMWOr16U = 0x36, + I64AtomicRMWOr8U = 0x37, + I64AtomicRMWOr16U = 0x38, + I64AtomicRMWOr32U = 0x39, + I32AtomicRMWXor = 0x3a, + I64AtomicRMWXor = 0x3b, + I32AtomicRMWXor8U = 0x3c, + I32AtomicRMWXor16U = 0x3d, + I64AtomicRMWXor8U = 0x3e, + I64AtomicRMWXor16U = 0x3f, + I64AtomicRMWXor32U = 0x40, + I32AtomicRMWXchg = 0x41, + I64AtomicRMWXchg = 0x42, + I32AtomicRMWXchg8U = 0x43, + I32AtomicRMWXchg16U = 0x44, + I64AtomicRMWXchg8U = 0x45, + I64AtomicRMWXchg16U = 0x46, + I64AtomicRMWXchg32U = 0x47, + AtomicRMWOps_End = 0x47, + + AtomicCmpxchgOps_Begin = 0x48, + I32AtomicCmpxchg = 0x48, + I64AtomicCmpxchg = 0x49, + I32AtomicCmpxchg8U = 0x4a, + I32AtomicCmpxchg16U = 0x4b, + I64AtomicCmpxchg8U = 0x4c, + I64AtomicCmpxchg16U = 0x4d, + I64AtomicCmpxchg32U = 0x4e, + AtomicCmpxchgOps_End = 0x4e, + + // truncsat opcodes + + I32STruncSatF32 = 0x00, + I32UTruncSatF32 = 0x01, + I32STruncSatF64 = 0x02, + I32UTruncSatF64 = 0x03, + I64STruncSatF32 = 0x04, + I64UTruncSatF32 = 0x05, + I64STruncSatF64 = 0x06, + I64UTruncSatF64 = 0x07, + + // SIMD opcodes + + V128Load = 0x00, + I16x8LoadExtSVec8x8 = 0x01, + I16x8LoadExtUVec8x8 = 0x02, + I32x4LoadExtSVec16x4 = 0x03, + I32x4LoadExtUVec16x4 = 0x04, + I64x2LoadExtSVec32x2 = 0x05, + I64x2LoadExtUVec32x2 = 0x06, + V8x16LoadSplat = 0x07, + V16x8LoadSplat = 0x08, + V32x4LoadSplat = 0x09, + V64x2LoadSplat = 0x0a, + V128Store = 0x0b, + + V128Const = 0x0c, + V8x16Shuffle = 0x0d, + V8x16Swizzle = 0x0e, + + I8x16Splat = 0x0f, + I16x8Splat = 0x10, + I32x4Splat = 0x11, + I64x2Splat = 0x12, + F32x4Splat = 0x13, + F64x2Splat = 0x14, + + I8x16ExtractLaneS = 0x15, + I8x16ExtractLaneU = 0x16, + I8x16ReplaceLane = 0x17, + I16x8ExtractLaneS = 0x18, + I16x8ExtractLaneU = 0x19, + I16x8ReplaceLane = 0x1a, + I32x4ExtractLane = 0x1b, + I32x4ReplaceLane = 0x1c, + I64x2ExtractLane = 0x1d, + I64x2ReplaceLane = 0x1e, + F32x4ExtractLane = 0x1f, + F32x4ReplaceLane = 0x20, + F64x2ExtractLane = 0x21, + F64x2ReplaceLane = 0x22, + + I8x16Eq = 0x23, + I8x16Ne = 0x24, + I8x16LtS = 0x25, + I8x16LtU = 0x26, + I8x16GtS = 0x27, + I8x16GtU = 0x28, + I8x16LeS = 0x29, + I8x16LeU = 0x2a, + I8x16GeS = 0x2b, + I8x16GeU = 0x2c, + I16x8Eq = 0x2d, + I16x8Ne = 0x2e, + I16x8LtS = 0x2f, + I16x8LtU = 0x30, + I16x8GtS = 0x31, + I16x8GtU = 0x32, + I16x8LeS = 0x33, + I16x8LeU = 0x34, + I16x8GeS = 0x35, + I16x8GeU = 0x36, + I32x4Eq = 0x37, + I32x4Ne = 0x38, + I32x4LtS = 0x39, + I32x4LtU = 0x3a, + I32x4GtS = 0x3b, + I32x4GtU = 0x3c, + I32x4LeS = 0x3d, + I32x4LeU = 0x3e, + I32x4GeS = 0x3f, + I32x4GeU = 0x40, + F32x4Eq = 0x41, + F32x4Ne = 0x42, + F32x4Lt = 0x43, + F32x4Gt = 0x44, + F32x4Le = 0x45, + F32x4Ge = 0x46, + F64x2Eq = 0x47, + F64x2Ne = 0x48, + F64x2Lt = 0x49, + F64x2Gt = 0x4a, + F64x2Le = 0x4b, + F64x2Ge = 0x4c, + + V128Not = 0x4d, + V128And = 0x4e, + V128AndNot = 0x4f, + V128Or = 0x50, + V128Xor = 0x51, + V128Bitselect = 0x52, + + I8x16Abs = 0x60, + I8x16Neg = 0x61, + I8x16AnyTrue = 0x62, + I8x16AllTrue = 0x63, + I8x16Bitmask = 0x64, + I8x16NarrowSI16x8 = 0x65, + I8x16NarrowUI16x8 = 0x66, + I8x16Shl = 0x6b, + I8x16ShrS = 0x6c, + I8x16ShrU = 0x6d, + I8x16Add = 0x6e, + I8x16AddSatS = 0x6f, + I8x16AddSatU = 0x70, + I8x16Sub = 0x71, + I8x16SubSatS = 0x72, + I8x16SubSatU = 0x73, + I8x16Mul = 0x75, + I8x16MinS = 0x76, + I8x16MinU = 0x77, + I8x16MaxS = 0x78, + I8x16MaxU = 0x79, + I8x16AvgrU = 0x7b, + + I16x8Abs = 0x80, + I16x8Neg = 0x81, + I16x8AnyTrue = 0x82, + I16x8AllTrue = 0x83, + I16x8Bitmask = 0x84, + I16x8NarrowSI32x4 = 0x85, + I16x8NarrowUI32x4 = 0x86, + I16x8WidenLowSI8x16 = 0x87, + I16x8WidenHighSI8x16 = 0x88, + I16x8WidenLowUI8x16 = 0x89, + I16x8WidenHighUI8x16 = 0x8a, + I16x8Shl = 0x8b, + I16x8ShrS = 0x8c, + I16x8ShrU = 0x8d, + I16x8Add = 0x8e, + I16x8AddSatS = 0x8f, + I16x8AddSatU = 0x90, + I16x8Sub = 0x91, + I16x8SubSatS = 0x92, + I16x8SubSatU = 0x93, + I16x8Mul = 0x95, + I16x8MinS = 0x96, + I16x8MinU = 0x97, + I16x8MaxS = 0x98, + I16x8MaxU = 0x99, + I16x8AvgrU = 0x9b, + + I32x4Abs = 0xa0, + I32x4Neg = 0xa1, + I32x4AnyTrue = 0xa2, + I32x4AllTrue = 0xa3, + I32x4Bitmask = 0xa4, + I32x4WidenLowSI16x8 = 0xa7, + I32x4WidenHighSI16x8 = 0xa8, + I32x4WidenLowUI16x8 = 0xa9, + I32x4WidenHighUI16x8 = 0xaa, + I32x4Shl = 0xab, + I32x4ShrS = 0xac, + I32x4ShrU = 0xad, + I32x4Add = 0xae, + I32x4Sub = 0xb1, + I32x4Mul = 0xb5, + I32x4MinS = 0xb6, + I32x4MinU = 0xb7, + I32x4MaxS = 0xb8, + I32x4MaxU = 0xb9, + I32x4DotSVecI16x8 = 0xba, + + I64x2Neg = 0xc1, + I64x2AnyTrue = 0xc2, + I64x2AllTrue = 0xc3, + I64x2Shl = 0xcb, + I64x2ShrS = 0xcc, + I64x2ShrU = 0xcd, + I64x2Add = 0xce, + I64x2Sub = 0xd1, + I64x2Mul = 0xd5, + + F32x4Abs = 0xe0, + F32x4Neg = 0xe1, + F32x4Sqrt = 0xe3, + F32x4Add = 0xe4, + F32x4Sub = 0xe5, + F32x4Mul = 0xe6, + F32x4Div = 0xe7, + F32x4Min = 0xe8, + F32x4Max = 0xe9, + F32x4PMin = 0xea, + F32x4PMax = 0xeb, + + F32x4Ceil = 0xd8, + F32x4Floor = 0xd9, + F32x4Trunc = 0xda, + F32x4Nearest = 0xdb, + F64x2Ceil = 0xdc, + F64x2Floor = 0xdd, + F64x2Trunc = 0xde, + F64x2Nearest = 0xdf, + + F64x2Abs = 0xec, + F64x2Neg = 0xed, + F64x2Sqrt = 0xef, + F64x2Add = 0xf0, + F64x2Sub = 0xf1, + F64x2Mul = 0xf2, + F64x2Div = 0xf3, + F64x2Min = 0xf4, + F64x2Max = 0xf5, + F64x2PMin = 0xf6, + F64x2PMax = 0xf7, + + I32x4TruncSatSF32x4 = 0xf8, + I32x4TruncSatUF32x4 = 0xf9, + F32x4ConvertSI32x4 = 0xfa, + F32x4ConvertUI32x4 = 0xfb, + + V128Load32Zero = 0xfc, + V128Load64Zero = 0xfd, + + F32x4QFMA = 0xb4, + F32x4QFMS = 0xd4, + F64x2QFMA = 0xfe, + F64x2QFMS = 0xff, + + I64x2TruncSatSF64x2 = 0x0100, + I64x2TruncSatUF64x2 = 0x0101, + F64x2ConvertSI64x2 = 0x0102, + F64x2ConvertUI64x2 = 0x0103, + + // bulk memory opcodes + + MemoryInit = 0x08, + DataDrop = 0x09, + MemoryCopy = 0x0a, + MemoryFill = 0x0b, + + // reference types opcodes + + RefNull = 0xd0, + RefIsNull = 0xd1, + RefFunc = 0xd2, + + // exception handling opcodes + + Try = 0x06, + Catch = 0x07, + Throw = 0x08, + Rethrow = 0x09, + BrOnExn = 0x0a, + + // gc opcodes + + RefEq = 0xd5, + StructNewWithRtt = 0x01, + StructNewDefaultWithRtt = 0x02, + StructGet = 0x03, + StructGetS = 0x04, + StructGetU = 0x05, + StructSet = 0x06, + ArrayNewWithRtt = 0x11, + ArrayNewDefaultWithRtt = 0x12, + ArrayGet = 0x13, + ArrayGetS = 0x14, + ArrayGetU = 0x15, + ArraySet = 0x16, + ArrayLen = 0x17, + I31New = 0x20, + I31GetS = 0x21, + I31GetU = 0x22, + RttCanon = 0x30, + RttSub = 0x31, + RefTest = 0x40, + RefCast = 0x41, + BrOnCast = 0x42 +}; + +enum MemoryAccess { + Offset = 0x10, // bit 4 + Alignment = 0x80, // bit 7 + NaturalAlignment = 0 +}; + +enum MemoryFlags { HasMaximum = 1 << 0, IsShared = 1 << 1, Is64 = 1 << 2 }; + +enum FeaturePrefix { + FeatureUsed = '+', + FeatureRequired = '=', + FeatureDisallowed = '-' +}; + +} // namespace BinaryConsts + +inline S32LEB binaryType(Type type) { + int ret = 0; + TODO_SINGLE_COMPOUND(type); + switch (type.getBasic()) { + // None only used for block signatures. TODO: Separate out? + case Type::none: + ret = BinaryConsts::EncodedType::Empty; + break; + case Type::i32: + ret = BinaryConsts::EncodedType::i32; + break; + case Type::i64: + ret = BinaryConsts::EncodedType::i64; + break; + case Type::f32: + ret = BinaryConsts::EncodedType::f32; + break; + case Type::f64: + ret = BinaryConsts::EncodedType::f64; + break; + case Type::v128: + ret = BinaryConsts::EncodedType::v128; + break; + case Type::funcref: + ret = BinaryConsts::EncodedType::funcref; + break; + case Type::externref: + ret = BinaryConsts::EncodedType::externref; + break; + case Type::exnref: + ret = BinaryConsts::EncodedType::exnref; + break; + case Type::anyref: + ret = BinaryConsts::EncodedType::anyref; + break; + case Type::eqref: + ret = BinaryConsts::EncodedType::eqref; + break; + case Type::i31ref: + ret = BinaryConsts::EncodedType::i31ref; + break; + case Type::unreachable: + WASM_UNREACHABLE("unexpected type"); + } + return S32LEB(ret); +} + +inline S32LEB binaryHeapType(HeapType type) { + int ret = 0; + switch (type.kind) { + case HeapType::FuncKind: + ret = BinaryConsts::EncodedHeapType::func; + break; + case HeapType::ExternKind: + ret = BinaryConsts::EncodedHeapType::extern_; + break; + case HeapType::ExnKind: + ret = BinaryConsts::EncodedHeapType::exn; + break; + case HeapType::AnyKind: + ret = BinaryConsts::EncodedHeapType::any; + break; + case HeapType::EqKind: + ret = BinaryConsts::EncodedHeapType::eq; + break; + case HeapType::I31Kind: + ret = BinaryConsts::EncodedHeapType::i31; + break; + case HeapType::SignatureKind: + case HeapType::StructKind: + case HeapType::ArrayKind: + WASM_UNREACHABLE("TODO: compound GC types"); + } + return S32LEB(ret); // TODO: Actually encoded as s33 +} + +// Writes out wasm to the binary format + +class WasmBinaryWriter { + // Computes the indexes in a wasm binary, i.e., with function imports + // and function implementations sharing a single index space, etc., + // and with the imports first (the Module's functions and globals + // arrays are not assumed to be in a particular order, so we can't + // just use them directly). + struct BinaryIndexes { + std::unordered_map functionIndexes; + std::unordered_map eventIndexes; + std::unordered_map globalIndexes; + + BinaryIndexes(Module& wasm) { + auto addIndexes = [&](auto& source, auto& indexes) { + auto addIndex = [&](auto* curr) { + auto index = indexes.size(); + indexes[curr->name] = index; + }; + for (auto& curr : source) { + if (curr->imported()) { + addIndex(curr.get()); + } + } + for (auto& curr : source) { + if (!curr->imported()) { + addIndex(curr.get()); + } + } + }; + addIndexes(wasm.functions, functionIndexes); + addIndexes(wasm.events, eventIndexes); + + // Globals may have tuple types in the IR, in which case they lower to + // multiple globals, one for each tuple element, in the binary. Tuple + // globals therefore occupy multiple binary indices, and we have to take + // that into account when calculating indices. + Index globalCount = 0; + auto addGlobal = [&](auto* curr) { + globalIndexes[curr->name] = globalCount; + globalCount += curr->type.size(); + }; + for (auto& curr : wasm.globals) { + if (curr->imported()) { + addGlobal(curr.get()); + } + } + for (auto& curr : wasm.globals) { + if (!curr->imported()) { + addGlobal(curr.get()); + } + } + } + }; + +public: + WasmBinaryWriter(Module* input, BufferWithRandomAccess& o) + : wasm(input), o(o), indexes(*input) { + prepare(); + } + + // locations in the output binary for the various parts of the module + struct TableOfContents { + struct Entry { + Name name; + size_t offset; // where the entry starts + size_t size; // the size of the entry + Entry(Name name, size_t offset, size_t size) + : name(name), offset(offset), size(size) {} + }; + std::vector functionBodies; + } tableOfContents; + + void setNamesSection(bool set) { debugInfo = set; } + void setSourceMap(std::ostream* set, std::string url) { + sourceMap = set; + sourceMapUrl = url; + } + void setSymbolMap(std::string set) { symbolMap = set; } + + void write(); + void writeHeader(); + int32_t writeU32LEBPlaceholder(); + void writeResizableLimits( + Address initial, Address maximum, bool hasMaximum, bool shared, bool is64); + template int32_t startSection(T code); + void finishSection(int32_t start); + int32_t startSubsection(BinaryConsts::UserSections::Subsection code); + void finishSubsection(int32_t start); + void writeStart(); + void writeMemory(); + void writeTypes(); + void writeImports(); + + void writeFunctionSignatures(); + void writeExpression(Expression* curr); + void writeFunctions(); + void writeGlobals(); + void writeExports(); + void writeDataCount(); + void writeDataSegments(); + void writeEvents(); + + uint32_t getFunctionIndex(Name name) const; + uint32_t getGlobalIndex(Name name) const; + uint32_t getEventIndex(Name name) const; + uint32_t getTypeIndex(Signature sig) const; + + void writeFunctionTableDeclaration(); + void writeTableElements(); + void writeNames(); + void writeSourceMapUrl(); + void writeSymbolMap(); + void writeLateUserSections(); + void writeUserSection(const UserSection& section); + void writeFeaturesSection(); + void writeDylinkSection(); + + void initializeDebugInfo(); + void writeSourceMapProlog(); + void writeSourceMapEpilog(); + void writeDebugLocation(const Function::DebugLocation& loc); + void writeDebugLocation(Expression* curr, Function* func); + void writeDebugLocationEnd(Expression* curr, Function* func); + void writeExtraDebugLocation(Expression* curr, + Function* func, + BinaryLocations::DelimiterId id); + + // helpers + void writeInlineString(const char* name); + void writeEscapedName(const char* name); + void writeInlineBuffer(const char* data, size_t size); + + struct Buffer { + const char* data; + size_t size; + size_t pointerLocation; + Buffer(const char* data, size_t size, size_t pointerLocation) + : data(data), size(size), pointerLocation(pointerLocation) {} + }; + + std::vector buffersToWrite; + + void emitBuffer(const char* data, size_t size); + void emitString(const char* str); + void finishUp(); + + Module* getModule() { return wasm; } + +private: + Module* wasm; + BufferWithRandomAccess& o; + BinaryIndexes indexes; + std::unordered_map typeIndices; + std::vector types; + + bool debugInfo = true; + std::ostream* sourceMap = nullptr; + std::string sourceMapUrl; + std::string symbolMap; + + MixedArena allocator; + + // storage of source map locations until the section is placed at its final + // location (shrinking LEBs may cause changes there) + std::vector> + sourceMapLocations; + size_t sourceMapLocationsSizeAtSectionStart; + Function::DebugLocation lastDebugLocation; + + std::unique_ptr importInfo; + + // General debugging info: track locations as we write. + BinaryLocations binaryLocations; + size_t binaryLocationsSizeAtSectionStart; + // Track the expressions that we added for the current function being + // written, so that we can update those specific binary locations when + // the function is written out. + std::vector binaryLocationTrackedExpressionsForFunc; + + void prepare(); +}; + +class WasmBinaryBuilder { + Module& wasm; + MixedArena& allocator; + const std::vector& input; + std::istream* sourceMap; + std::pair nextDebugLocation; + bool DWARF = false; + + size_t pos = 0; + Index startIndex = -1; + std::set debugLocation; + size_t codeSectionLocation; + + std::set seenSections; + + // All signatures present in the type section + std::vector signatures; + +public: + WasmBinaryBuilder(Module& wasm, const std::vector& input) + : wasm(wasm), allocator(wasm.allocator), input(input), sourceMap(nullptr), + nextDebugLocation(0, {0, 0, 0}), debugLocation() {} + + void setDWARF(bool value) { DWARF = value; } + void read(); + void readUserSection(size_t payloadLen); + + bool more() { return pos < input.size(); } + + uint8_t getInt8(); + uint16_t getInt16(); + uint32_t getInt32(); + uint64_t getInt64(); + uint8_t getLaneIndex(size_t lanes); + // it is unsafe to return a float directly, due to ABI issues with the + // signalling bit + Literal getFloat32Literal(); + Literal getFloat64Literal(); + Literal getVec128Literal(); + uint32_t getU32LEB(); + uint64_t getU64LEB(); + int32_t getS32LEB(); + int64_t getS64LEB(); + Type getType(); + HeapType getHeapType(); + Type getConcreteType(); + Name getInlineString(); + void verifyInt8(int8_t x); + void verifyInt16(int16_t x); + void verifyInt32(int32_t x); + void verifyInt64(int64_t x); + void ungetInt8(); + void readHeader(); + void readStart(); + void readMemory(); + void readSignatures(); + + // gets a name in the combined import+defined space + Name getFunctionName(Index index); + Name getGlobalName(Index index); + Name getEventName(Index index); + + void getResizableLimits(Address& initial, + Address& max, + bool& shared, + Type& indexType, + Address defaultIfNoMax); + void readImports(); + + // The signatures of each function, given in the function section + std::vector functionSignatures; + + void readFunctionSignatures(); + size_t nextLabel; + + Name getNextLabel(); + + // We read functions and globals before we know their names, so we need to + // backpatch the names later + + // we store functions here before wasm.addFunction after we know their names + std::vector functions; + // we store function imports here before wasm.addFunctionImport after we know + // their names + std::vector functionImports; + // at index i we have all refs to the function i + std::map> functionRefs; + Function* currFunction = nullptr; + // before we see a function (like global init expressions), there is no end of + // function to check + Index endOfFunction = -1; + + // we store globals here before wasm.addGlobal after we know their names + std::vector globals; + // we store global imports here before wasm.addGlobalImport after we know + // their names + std::vector globalImports; + // at index i we have all refs to the global i + std::map> globalRefs; + + // Throws a parsing error if we are not in a function context + void requireFunctionContext(const char* error); + + void readFunctions(); + + std::map exportIndices; + std::vector exportOrder; + void readExports(); + + Expression* readExpression(); + void readGlobals(); + + struct BreakTarget { + Name name; + Type type; + BreakTarget(Name name, Type type) : name(name), type(type) {} + }; + std::vector breakStack; + // the names that breaks target. this lets us know if a block has breaks to it + // or not. + std::unordered_set breakTargetNames; + + std::vector expressionStack; + + // Control flow structure parsing: these have not just the normal binary + // data for an instruction, but also some bytes later on like "end" or "else". + // We must be aware of the connection between those things, for debug info. + std::vector controlFlowStack; + + // Called when we parse the beginning of a control flow structure. + void startControlFlow(Expression* curr); + + // Called when we parse a later part of a control flow structure, like "end" + // or "else". + void continueControlFlow(BinaryLocations::DelimiterId id, BinaryLocation pos); + + // set when we know code is unreachable in the sense of the wasm spec: we are + // in a block and after an unreachable element. this helps parse stacky wasm + // code, which can be unsuitable for our IR when unreachable. + bool unreachableInTheWasmSense; + + // set when the current code being processed will not be emitted in the + // output, which is the case when it is literally unreachable, for example, + // (block $a + // (unreachable) + // (block $b + // ;; code here is reachable in the wasm sense, even though $b as a whole + // ;; is not + // (unreachable) + // ;; code here is unreachable in the wasm sense + // ) + // ) + bool willBeIgnored; + + BinaryConsts::ASTNodes lastSeparator = BinaryConsts::End; + + // process a block-type scope, until an end or else marker, or the end of the + // function + void processExpressions(); + void skipUnreachableCode(); + + void pushExpression(Expression* curr); + Expression* popExpression(); + Expression* popNonVoidExpression(); + Expression* popTuple(size_t numElems); + Expression* popTypedExpression(Type type); + + void validateBinary(); // validations that cannot be performed on the Module + void processNames(); + + size_t dataCount = 0; + bool hasDataCount = false; + + void readDataSegments(); + void readDataCount(); + + std::map> functionTable; + + void readFunctionTableDeclaration(); + void readTableElements(); + + void readEvents(); + + static Name escape(Name name); + void readNames(size_t); + void readFeatures(size_t); + void readDylink(size_t); + + // Debug information reading helpers + void setDebugLocations(std::istream* sourceMap_) { sourceMap = sourceMap_; } + std::unordered_map debugInfoFileIndices; + void readNextDebugLocation(); + void readSourceMapHeader(); + + void handleBrOnExnNotTaken(Expression* curr); + + // AST reading + int depth = 0; // only for debugging + + BinaryConsts::ASTNodes readExpression(Expression*& curr); + void pushBlockElements(Block* curr, Type type, size_t start); + void visitBlock(Block* curr); + + // Gets a block of expressions. If it's just one, return that singleton. + Expression* getBlockOrSingleton(Type type); + + void visitIf(If* curr); + void visitLoop(Loop* curr); + BreakTarget getBreakTarget(int32_t offset); + void visitBreak(Break* curr, uint8_t code); + void visitSwitch(Switch* curr); + + void visitCall(Call* curr); + void visitCallIndirect(CallIndirect* curr); + void visitLocalGet(LocalGet* curr); + void visitLocalSet(LocalSet* curr, uint8_t code); + void visitGlobalGet(GlobalGet* curr); + void visitGlobalSet(GlobalSet* curr); + void readMemoryAccess(Address& alignment, Address& offset); + bool maybeVisitLoad(Expression*& out, uint8_t code, bool isAtomic); + bool maybeVisitStore(Expression*& out, uint8_t code, bool isAtomic); + bool maybeVisitNontrappingTrunc(Expression*& out, uint32_t code); + bool maybeVisitAtomicRMW(Expression*& out, uint8_t code); + bool maybeVisitAtomicCmpxchg(Expression*& out, uint8_t code); + bool maybeVisitAtomicWait(Expression*& out, uint8_t code); + bool maybeVisitAtomicNotify(Expression*& out, uint8_t code); + bool maybeVisitAtomicFence(Expression*& out, uint8_t code); + bool maybeVisitConst(Expression*& out, uint8_t code); + bool maybeVisitUnary(Expression*& out, uint8_t code); + bool maybeVisitBinary(Expression*& out, uint8_t code); + bool maybeVisitTruncSat(Expression*& out, uint32_t code); + bool maybeVisitSIMDBinary(Expression*& out, uint32_t code); + bool maybeVisitSIMDUnary(Expression*& out, uint32_t code); + bool maybeVisitSIMDConst(Expression*& out, uint32_t code); + bool maybeVisitSIMDStore(Expression*& out, uint32_t code); + bool maybeVisitSIMDExtract(Expression*& out, uint32_t code); + bool maybeVisitSIMDReplace(Expression*& out, uint32_t code); + bool maybeVisitSIMDShuffle(Expression*& out, uint32_t code); + bool maybeVisitSIMDTernary(Expression*& out, uint32_t code); + bool maybeVisitSIMDShift(Expression*& out, uint32_t code); + bool maybeVisitSIMDLoad(Expression*& out, uint32_t code); + bool maybeVisitMemoryInit(Expression*& out, uint32_t code); + bool maybeVisitDataDrop(Expression*& out, uint32_t code); + bool maybeVisitMemoryCopy(Expression*& out, uint32_t code); + bool maybeVisitMemoryFill(Expression*& out, uint32_t code); + bool maybeVisitI31New(Expression*& out, uint32_t code); + bool maybeVisitI31Get(Expression*& out, uint32_t code); + bool maybeVisitRefTest(Expression*& out, uint32_t code); + bool maybeVisitRefCast(Expression*& out, uint32_t code); + bool maybeVisitBrOnCast(Expression*& out, uint32_t code); + bool maybeVisitRttCanon(Expression*& out, uint32_t code); + bool maybeVisitRttSub(Expression*& out, uint32_t code); + bool maybeVisitStructNew(Expression*& out, uint32_t code); + bool maybeVisitStructGet(Expression*& out, uint32_t code); + bool maybeVisitStructSet(Expression*& out, uint32_t code); + bool maybeVisitArrayNew(Expression*& out, uint32_t code); + bool maybeVisitArrayGet(Expression*& out, uint32_t code); + bool maybeVisitArraySet(Expression*& out, uint32_t code); + bool maybeVisitArrayLen(Expression*& out, uint32_t code); + void visitSelect(Select* curr, uint8_t code); + void visitReturn(Return* curr); + void visitMemorySize(MemorySize* curr); + void visitMemoryGrow(MemoryGrow* curr); + void visitNop(Nop* curr); + void visitUnreachable(Unreachable* curr); + void visitDrop(Drop* curr); + void visitRefNull(RefNull* curr); + void visitRefIsNull(RefIsNull* curr); + void visitRefFunc(RefFunc* curr); + void visitRefEq(RefEq* curr); + void visitTryOrTryInBlock(Expression*& out); + void visitThrow(Throw* curr); + void visitRethrow(Rethrow* curr); + void visitBrOnExn(BrOnExn* curr); + + void throwError(std::string text); + +private: + bool hasDWARFSections(); +}; + +} // namespace wasm + +#undef DEBUG_TYPE + +#endif // wasm_wasm_binary_h diff --git a/binaryen/src/wasm-builder.h b/binaryen/src/wasm-builder.h new file mode 100644 --- /dev/null +++ b/binaryen/src/wasm-builder.h @@ -0,0 +1,972 @@ +/* + * Copyright 2016 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef wasm_wasm_builder_h +#define wasm_wasm_builder_h + +#include "ir/manipulation.h" +#include "wasm.h" + +namespace wasm { + +// Useful data structures + +struct NameType { + Name name; + Type type; + NameType() : name(nullptr), type(Type::none) {} + NameType(Name name, Type type) : name(name), type(type) {} +}; + +// General AST node builder + +class Builder { + Module& wasm; + +public: + Builder(Module& wasm) : wasm(wasm) {} + + // make* functions, other globals + + Function* makeFunction(Name name, + Signature sig, + std::vector&& vars, + Expression* body = nullptr) { + auto* func = new Function; + func->name = name; + func->sig = sig; + func->body = body; + func->vars.swap(vars); + return func; + } + + Function* makeFunction(Name name, + std::vector&& params, + Type resultType, + std::vector&& vars, + Expression* body = nullptr) { + auto* func = new Function; + func->name = name; + func->body = body; + std::vector paramVec; + for (auto& param : params) { + paramVec.push_back(param.type); + Index index = func->localNames.size(); + func->localIndices[param.name] = index; + func->localNames[index] = param.name; + } + func->sig = Signature(Type(paramVec), resultType); + for (auto& var : vars) { + func->vars.push_back(var.type); + Index index = func->localNames.size(); + func->localIndices[var.name] = index; + func->localNames[index] = var.name; + } + return func; + } + + Export* makeExport(Name name, Name value, ExternalKind kind) { + auto* export_ = new Export(); + export_->name = name; + export_->value = value; + export_->kind = kind; + return export_; + } + + // IR nodes + + Nop* makeNop() { return wasm.allocator.alloc(); } + Block* makeBlock(Expression* first = nullptr) { + auto* ret = wasm.allocator.alloc(); + if (first) { + ret->list.push_back(first); + ret->finalize(); + } + return ret; + } + Block* makeBlock(Name name, Expression* first = nullptr) { + auto* ret = makeBlock(first); + ret->name = name; + ret->finalize(); + return ret; + } + Block* makeBlock(const std::vector& items) { + auto* ret = wasm.allocator.alloc(); + ret->list.set(items); + ret->finalize(); + return ret; + } + Block* makeBlock(const std::vector& items, Type type) { + auto* ret = wasm.allocator.alloc(); + ret->list.set(items); + ret->finalize(type); + return ret; + } + Block* makeBlock(const ExpressionList& items) { + auto* ret = wasm.allocator.alloc(); + ret->list.set(items); + ret->finalize(); + return ret; + } + Block* makeBlock(const ExpressionList& items, Type type) { + auto* ret = wasm.allocator.alloc(); + ret->list.set(items); + ret->finalize(type); + return ret; + } + Block* makeBlock(Name name, const ExpressionList& items) { + auto* ret = wasm.allocator.alloc(); + ret->name = name; + ret->list.set(items); + ret->finalize(); + return ret; + } + Block* makeBlock(Name name, const ExpressionList& items, Type type) { + auto* ret = wasm.allocator.alloc(); + ret->name = name; + ret->list.set(items); + ret->finalize(type); + return ret; + } + If* makeIf(Expression* condition, + Expression* ifTrue, + Expression* ifFalse = nullptr) { + auto* ret = wasm.allocator.alloc(); + ret->condition = condition; + ret->ifTrue = ifTrue; + ret->ifFalse = ifFalse; + ret->finalize(); + return ret; + } + If* makeIf(Expression* condition, + Expression* ifTrue, + Expression* ifFalse, + Type type) { + auto* ret = wasm.allocator.alloc(); + ret->condition = condition; + ret->ifTrue = ifTrue; + ret->ifFalse = ifFalse; + ret->finalize(type); + return ret; + } + Loop* makeLoop(Name name, Expression* body) { + auto* ret = wasm.allocator.alloc(); + ret->name = name; + ret->body = body; + ret->finalize(); + return ret; + } + Loop* makeLoop(Name name, Expression* body, Type type) { + auto* ret = wasm.allocator.alloc(); + ret->name = name; + ret->body = body; + ret->finalize(type); + return ret; + } + Break* makeBreak(Name name, + Expression* value = nullptr, + Expression* condition = nullptr) { + auto* ret = wasm.allocator.alloc(); + ret->name = name; + ret->value = value; + ret->condition = condition; + ret->finalize(); + return ret; + } + template + Switch* makeSwitch(T& list, + Name default_, + Expression* condition, + Expression* value = nullptr) { + auto* ret = wasm.allocator.alloc(); + ret->targets.set(list); + ret->default_ = default_; + ret->value = value; + ret->condition = condition; + return ret; + } + Call* makeCall(Name target, + const std::vector& args, + Type type, + bool isReturn = false) { + auto* call = wasm.allocator.alloc(); + // not all functions may exist yet, so type must be provided + call->type = type; + call->target = target; + call->operands.set(args); + call->isReturn = isReturn; + return call; + } + template + Call* makeCall(Name target, const T& args, Type type, bool isReturn = false) { + auto* call = wasm.allocator.alloc(); + // not all functions may exist yet, so type must be provided + call->type = type; + call->target = target; + call->operands.set(args); + call->isReturn = isReturn; + call->finalize(); + return call; + } + CallIndirect* makeCallIndirect(Expression* target, + const std::vector& args, + Signature sig, + bool isReturn = false) { + auto* call = wasm.allocator.alloc(); + call->sig = sig; + call->type = sig.results; + call->target = target; + call->operands.set(args); + call->isReturn = isReturn; + call->finalize(); + return call; + } + LocalGet* makeLocalGet(Index index, Type type) { + auto* ret = wasm.allocator.alloc(); + ret->index = index; + ret->type = type; + return ret; + } + LocalSet* makeLocalSet(Index index, Expression* value) { + auto* ret = wasm.allocator.alloc(); + ret->index = index; + ret->value = value; + ret->makeSet(); + ret->finalize(); + return ret; + } + LocalSet* makeLocalTee(Index index, Expression* value, Type type) { + auto* ret = wasm.allocator.alloc(); + ret->index = index; + ret->value = value; + ret->makeTee(type); + return ret; + } + GlobalGet* makeGlobalGet(Name name, Type type) { + auto* ret = wasm.allocator.alloc(); + ret->name = name; + ret->type = type; + return ret; + } + GlobalSet* makeGlobalSet(Name name, Expression* value) { + auto* ret = wasm.allocator.alloc(); + ret->name = name; + ret->value = value; + ret->finalize(); + return ret; + } + Load* makeLoad(unsigned bytes, + bool signed_, + uint32_t offset, + unsigned align, + Expression* ptr, + Type type) { + auto* ret = wasm.allocator.alloc(); + ret->isAtomic = false; + ret->bytes = bytes; + ret->signed_ = signed_; + ret->offset = offset; + ret->align = align; + ret->ptr = ptr; + ret->type = type; + return ret; + } + Load* + makeAtomicLoad(unsigned bytes, uint32_t offset, Expression* ptr, Type type) { + Load* load = makeLoad(bytes, false, offset, bytes, ptr, type); + load->isAtomic = true; + return load; + } + AtomicWait* makeAtomicWait(Expression* ptr, + Expression* expected, + Expression* timeout, + Type expectedType, + Address offset) { + auto* wait = wasm.allocator.alloc(); + wait->offset = offset; + wait->ptr = ptr; + wait->expected = expected; + wait->timeout = timeout; + wait->expectedType = expectedType; + wait->finalize(); + return wait; + } + AtomicNotify* + makeAtomicNotify(Expression* ptr, Expression* notifyCount, Address offset) { + auto* notify = wasm.allocator.alloc(); + notify->offset = offset; + notify->ptr = ptr; + notify->notifyCount = notifyCount; + notify->finalize(); + return notify; + } + AtomicFence* makeAtomicFence() { return wasm.allocator.alloc(); } + Store* makeStore(unsigned bytes, + uint32_t offset, + unsigned align, + Expression* ptr, + Expression* value, + Type type) { + auto* ret = wasm.allocator.alloc(); + ret->isAtomic = false; + ret->bytes = bytes; + ret->offset = offset; + ret->align = align; + ret->ptr = ptr; + ret->value = value; + ret->valueType = type; + ret->finalize(); + assert(ret->value->type.isConcrete() ? ret->value->type == type : true); + return ret; + } + Store* makeAtomicStore(unsigned bytes, + uint32_t offset, + Expression* ptr, + Expression* value, + Type type) { + Store* store = makeStore(bytes, offset, bytes, ptr, value, type); + store->isAtomic = true; + return store; + } + AtomicRMW* makeAtomicRMW(AtomicRMWOp op, + unsigned bytes, + uint32_t offset, + Expression* ptr, + Expression* value, + Type type) { + auto* ret = wasm.allocator.alloc(); + ret->op = op; + ret->bytes = bytes; + ret->offset = offset; + ret->ptr = ptr; + ret->value = value; + ret->type = type; + ret->finalize(); + return ret; + } + AtomicCmpxchg* makeAtomicCmpxchg(unsigned bytes, + uint32_t offset, + Expression* ptr, + Expression* expected, + Expression* replacement, + Type type) { + auto* ret = wasm.allocator.alloc(); + ret->bytes = bytes; + ret->offset = offset; + ret->ptr = ptr; + ret->expected = expected; + ret->replacement = replacement; + ret->type = type; + ret->finalize(); + return ret; + } + SIMDExtract* + makeSIMDExtract(SIMDExtractOp op, Expression* vec, uint8_t index) { + auto* ret = wasm.allocator.alloc(); + ret->op = op; + ret->vec = vec; + ret->index = index; + ret->finalize(); + return ret; + } + SIMDReplace* makeSIMDReplace(SIMDReplaceOp op, + Expression* vec, + uint8_t index, + Expression* value) { + auto* ret = wasm.allocator.alloc(); + ret->op = op; + ret->vec = vec; + ret->index = index; + ret->value = value; + ret->finalize(); + return ret; + } + SIMDShuffle* makeSIMDShuffle(Expression* left, + Expression* right, + const std::array& mask) { + auto* ret = wasm.allocator.alloc(); + ret->left = left; + ret->right = right; + ret->mask = mask; + ret->finalize(); + return ret; + } + SIMDTernary* makeSIMDTernary(SIMDTernaryOp op, + Expression* a, + Expression* b, + Expression* c) { + auto* ret = wasm.allocator.alloc(); + ret->op = op; + ret->a = a; + ret->b = b; + ret->c = c; + ret->finalize(); + return ret; + } + SIMDShift* makeSIMDShift(SIMDShiftOp op, Expression* vec, Expression* shift) { + auto* ret = wasm.allocator.alloc(); + ret->op = op; + ret->vec = vec; + ret->shift = shift; + ret->finalize(); + return ret; + } + SIMDLoad* + makeSIMDLoad(SIMDLoadOp op, Address offset, Address align, Expression* ptr) { + auto* ret = wasm.allocator.alloc(); + ret->op = op; + ret->offset = offset; + ret->align = align; + ret->ptr = ptr; + ret->finalize(); + return ret; + } + MemoryInit* makeMemoryInit(uint32_t segment, + Expression* dest, + Expression* offset, + Expression* size) { + auto* ret = wasm.allocator.alloc(); + ret->segment = segment; + ret->dest = dest; + ret->offset = offset; + ret->size = size; + ret->finalize(); + return ret; + } + DataDrop* makeDataDrop(uint32_t segment) { + auto* ret = wasm.allocator.alloc(); + ret->segment = segment; + ret->finalize(); + return ret; + } + MemoryCopy* + makeMemoryCopy(Expression* dest, Expression* source, Expression* size) { + auto* ret = wasm.allocator.alloc(); + ret->dest = dest; + ret->source = source; + ret->size = size; + ret->finalize(); + return ret; + } + MemoryFill* + makeMemoryFill(Expression* dest, Expression* value, Expression* size) { + auto* ret = wasm.allocator.alloc(); + ret->dest = dest; + ret->value = value; + ret->size = size; + ret->finalize(); + return ret; + } + Const* makeConst(Literal value) { + assert(value.type.isNumber()); + auto* ret = wasm.allocator.alloc(); + ret->value = value; + ret->type = value.type; + return ret; + } + template Const* makeConst(T x) { return makeConst(Literal(x)); } + Unary* makeUnary(UnaryOp op, Expression* value) { + auto* ret = wasm.allocator.alloc(); + ret->op = op; + ret->value = value; + ret->finalize(); + return ret; + } + Const* makeConstPtr(uint64_t val) { + return makeConst(Literal::makeFromInt64(val, wasm.memory.indexType)); + } + Binary* makeBinary(BinaryOp op, Expression* left, Expression* right) { + auto* ret = wasm.allocator.alloc(); + ret->op = op; + ret->left = left; + ret->right = right; + ret->finalize(); + return ret; + } + Select* + makeSelect(Expression* condition, Expression* ifTrue, Expression* ifFalse) { + auto* ret = wasm.allocator.alloc(); + ret->condition = condition; + ret->ifTrue = ifTrue; + ret->ifFalse = ifFalse; + ret->finalize(type); + return ret; + } + Return* makeReturn(Expression* value = nullptr) { + auto* ret = wasm.allocator.alloc(); + ret->value = value; + return ret; + } + MemorySize* makeMemorySize() { + auto* ret = wasm.allocator.alloc(); + if (wasm.memory.is64()) { + ret->make64(); + } + ret->finalize(); + return ret; + } + MemoryGrow* makeMemoryGrow(Expression* delta) { + auto* ret = wasm.allocator.alloc(); + if (wasm.memory.is64()) { + ret->make64(); + } + ret->delta = delta; + ret->finalize(); + return ret; + } + RefNull* makeRefNull(Type type) { + auto* ret = wasm.allocator.alloc(); + ret->finalize(type); + return ret; + } + RefIsNull* makeRefIsNull(Expression* value) { + auto* ret = wasm.allocator.alloc(); + ret->value = value; + ret->finalize(); + return ret; + } + RefFunc* makeRefFunc(Name func) { + auto* ret = wasm.allocator.alloc(); + ret->func = func; + ret->finalize(); + return ret; + } + RefEq* makeRefEq(Expression* left, Expression* right) { + auto* ret = wasm.allocator.alloc(); + ret->left = left; + ret->right = right; + ret->finalize(); + return ret; + } + Try* makeTry(Expression* body, Expression* catchBody) { + auto* ret = wasm.allocator.alloc(); + ret->body = body; + ret->catchBody = catchBody; + ret->finalize(); + return ret; + } + Try* makeTry(Expression* body, Expression* catchBody, Type type) { + auto* ret = wasm.allocator.alloc(); + ret->body = body; + ret->catchBody = catchBody; + ret->finalize(type); + return ret; + } + Throw* makeThrow(Event* event, const std::vector& args) { + return makeThrow(event->name, args); + } + Throw* makeThrow(Name event, const std::vector& args) { + auto* ret = wasm.allocator.alloc(); + ret->event = event; + ret->operands.set(args); + ret->finalize(); + return ret; + } + Rethrow* makeRethrow(Expression* exnref) { + auto* ret = wasm.allocator.alloc(); + ret->exnref = exnref; + ret->finalize(); + return ret; + } + BrOnExn* makeBrOnExn(Name name, Event* event, Expression* exnref) { + return makeBrOnExn(name, event->name, exnref, event->sig.params); + } + BrOnExn* makeBrOnExn(Name name, Name event, Expression* exnref, Type sent) { + auto* ret = wasm.allocator.alloc(); + ret->name = name; + ret->event = event; + ret->exnref = exnref; + // Copy params info into BrOnExn, because it is necessary when BrOnExn is + // refinalized without the module. + ret->sent = sent; + ret->finalize(); + return ret; + } + Unreachable* makeUnreachable() { return wasm.allocator.alloc(); } + Pop* makePop(Type type) { + auto* ret = wasm.allocator.alloc(); + ret->type = type; + ret->finalize(); + return ret; + } + template TupleMake* makeTupleMake(ListType&& operands) { + auto* ret = wasm.allocator.alloc(); + ret->operands.set(operands); + ret->finalize(); + return ret; + } + TupleExtract* makeTupleExtract(Expression* tuple, Index index) { + auto* ret = wasm.allocator.alloc(); + ret->tuple = tuple; + ret->index = index; + ret->finalize(); + return ret; + } + I31New* makeI31New(Expression* value) { + auto* ret = wasm.allocator.alloc(); + ret->value = value; + ret->finalize(); + return ret; + } + I31Get* makeI31Get(Expression* i31, bool signed_) { + auto* ret = wasm.allocator.alloc(); + ret->i31 = i31; + ret->signed_ = signed_; + ret->finalize(); + return ret; + } + RefTest* makeRefTest() { + auto* ret = wasm.allocator.alloc(); + WASM_UNREACHABLE("TODO (gc): ref.test"); + ret->finalize(); + return ret; + } + RefCast* makeRefCast() { + auto* ret = wasm.allocator.alloc(); + WASM_UNREACHABLE("TODO (gc): ref.cast"); + ret->finalize(); + return ret; + } + BrOnCast* makeBrOnCast() { + auto* ret = wasm.allocator.alloc(); + WASM_UNREACHABLE("TODO (gc): br_on_cast"); + ret->finalize(); + return ret; + } + RttCanon* makeRttCanon() { + auto* ret = wasm.allocator.alloc(); + WASM_UNREACHABLE("TODO (gc): rtt.canon"); + ret->finalize(); + return ret; + } + RttSub* makeRttSub() { + auto* ret = wasm.allocator.alloc(); + WASM_UNREACHABLE("TODO (gc): rtt.sub"); + ret->finalize(); + return ret; + } + StructNew* makeStructNew() { + auto* ret = wasm.allocator.alloc(); + WASM_UNREACHABLE("TODO (gc): struct.new"); + ret->finalize(); + return ret; + } + StructGet* makeStructGet() { + auto* ret = wasm.allocator.alloc(); + WASM_UNREACHABLE("TODO (gc): struct.get"); + ret->finalize(); + return ret; + } + StructSet* makeStructSet() { + auto* ret = wasm.allocator.alloc(); + WASM_UNREACHABLE("TODO (gc): struct.set"); + ret->finalize(); + return ret; + } + ArrayNew* makeArrayNew() { + auto* ret = wasm.allocator.alloc(); + WASM_UNREACHABLE("TODO (gc): array.new"); + ret->finalize(); + return ret; + } + ArrayGet* makeArrayGet() { + auto* ret = wasm.allocator.alloc(); + WASM_UNREACHABLE("TODO (gc): array.get"); + ret->finalize(); + return ret; + } + ArraySet* makeArraySet() { + auto* ret = wasm.allocator.alloc(); + WASM_UNREACHABLE("TODO (gc): array.set"); + ret->finalize(); + return ret; + } + ArrayLen* makeArrayLen() { + auto* ret = wasm.allocator.alloc(); + WASM_UNREACHABLE("TODO (gc): array.len"); + ret->finalize(); + return ret; + } + + // Additional helpers + + Drop* makeDrop(Expression* value) { + auto* ret = wasm.allocator.alloc(); + ret->value = value; + ret->finalize(); + return ret; + } + + // Make a constant expression. This might be a wasm Const, or something + // else of constant value like ref.null. + Expression* makeConstantExpression(Literal value) { + TODO_SINGLE_COMPOUND(value.type); + switch (value.type.getBasic()) { + case Type::funcref: + if (!value.isNull()) { + return makeRefFunc(value.getFunc()); + } + return makeRefNull(value.type); + case Type::externref: + case Type::exnref: // TODO: ExceptionPackage? + case Type::anyref: + case Type::eqref: + assert(value.isNull() && "unexpected non-null reference type literal"); + return makeRefNull(value.type); + case Type::i31ref: + return makeI31New(makeConst(value.geti31())); + default: + assert(value.type.isNumber()); + return makeConst(value); + } + } + + Expression* makeConstantExpression(Literals values) { + assert(values.size() > 0); + if (values.size() == 1) { + return makeConstantExpression(values[0]); + } else { + std::vector consts; + for (auto value : values) { + consts.push_back(makeConstantExpression(value)); + } + return makeTupleMake(consts); + } + } + + // Additional utility functions for building on top of nodes + // Convenient to have these on Builder, as it has allocation built in + + static Index addParam(Function* func, Name name, Type type) { + // only ok to add a param if no vars, otherwise indices are invalidated + assert(func->localIndices.size() == func->sig.params.size()); + assert(name.is()); + std::vector params(func->sig.params.begin(), func->sig.params.end()); + params.push_back(type); + func->sig.params = Type(params); + Index index = func->localNames.size(); + func->localIndices[name] = index; + func->localNames[index] = name; + return index; + } + + static Index addVar(Function* func, Name name, Type type) { + // always ok to add a var, it does not affect other indices + assert(type.isConcrete()); + Index index = func->getNumLocals(); + if (name.is()) { + func->localIndices[name] = index; + func->localNames[index] = name; + } + func->vars.emplace_back(type); + return index; + } + + static Index addVar(Function* func, Type type) { + return addVar(func, Name(), type); + } + + static void clearLocalNames(Function* func) { + func->localNames.clear(); + func->localIndices.clear(); + } + + static void clearLocals(Function* func) { + func->sig.params = Type::none; + func->vars.clear(); + clearLocalNames(func); + } + + // ensure a node is a block, if it isn't already, and optionally append to the + // block + Block* blockify(Expression* any, Expression* append = nullptr) { + Block* block = nullptr; + if (any) { + block = any->dynCast(); + } + if (!block) { + block = makeBlock(any); + } + if (append) { + block->list.push_back(append); + block->finalize(); + } + return block; + } + + template + Block* blockify(Expression* any, Expression* append, Ts... args) { + return blockify(blockify(any, append), args...); + } + + // ensure a node is a block, if it isn't already, and optionally append to the + // block this variant sets a name for the block, so it will not reuse a block + // already named + Block* + blockifyWithName(Expression* any, Name name, Expression* append = nullptr) { + Block* block = nullptr; + if (any) { + block = any->dynCast(); + } + if (!block || block->name.is()) { + block = makeBlock(any); + } + block->name = name; + if (append) { + block->list.push_back(append); + block->finalize(); + } + return block; + } + + // a helper for the common pattern of a sequence of two expressions. Similar + // to blockify, but does *not* reuse a block if the first is one. + Block* makeSequence(Expression* left, Expression* right) { + auto* block = makeBlock(left); + block->list.push_back(right); + block->finalize(); + return block; + } + + Block* makeSequence(Expression* left, Expression* right, Type type) { + auto* block = makeBlock(left); + block->list.push_back(right); + block->finalize(type); + return block; + } + + // Grab a slice out of a block, replacing it with nops, and returning + // either another block with the contents (if more than 1) or a single + // expression + Expression* stealSlice(Block* input, Index from, Index to) { + Expression* ret; + if (to == from + 1) { + // just one + ret = input->list[from]; + } else { + auto* block = wasm.allocator.alloc(); + for (Index i = from; i < to; i++) { + block->list.push_back(input->list[i]); + } + block->finalize(); + ret = block; + } + if (to == input->list.size()) { + input->list.resize(from); + } else { + for (Index i = from; i < to; i++) { + input->list[i] = wasm.allocator.alloc(); + } + } + input->finalize(); + return ret; + } + + // Drop an expression if it has a concrete type + Expression* dropIfConcretelyTyped(Expression* curr) { + if (!curr->type.isConcrete()) { + return curr; + } + return makeDrop(curr); + } + + void flip(If* iff) { + std::swap(iff->ifTrue, iff->ifFalse); + iff->condition = makeUnary(EqZInt32, iff->condition); + } + + // returns a replacement with the precise same type, and with + // minimal contents. as a replacement, this may reuse the + // input node + template Expression* replaceWithIdenticalType(T* curr) { + if (curr->type.isTuple()) { + return makeConstantExpression(Literal::makeZeros(curr->type)); + } + Literal value; + // TODO: reuse node conditionally when possible for literals + TODO_SINGLE_COMPOUND(curr->type); + switch (curr->type.getBasic()) { + case Type::i32: + value = Literal(int32_t(0)); + break; + case Type::i64: + value = Literal(int64_t(0)); + break; + case Type::f32: + value = Literal(float(0)); + break; + case Type::f64: + value = Literal(double(0)); + break; + case Type::v128: { + std::array bytes; + bytes.fill(0); + value = Literal(bytes.data()); + break; + } + case Type::funcref: + case Type::externref: + case Type::exnref: + case Type::anyref: + case Type::eqref: + return ExpressionManipulator::refNull(curr, curr->type); + case Type::i31ref: + return makeI31New(makeConst(0)); + case Type::none: + return ExpressionManipulator::nop(curr); + case Type::unreachable: + return ExpressionManipulator::unreachable(curr); + } + return makeConst(value); + } + + // Module-level helpers + + enum Mutability { Mutable, Immutable }; + + static Global* + makeGlobal(Name name, Type type, Expression* init, Mutability mutable_) { + auto* glob = new Global; + glob->name = name; + glob->type = type; + glob->init = init; + glob->mutable_ = mutable_ == Mutable; + return glob; + } + + static Event* makeEvent(Name name, uint32_t attribute, Signature sig) { + auto* event = new Event; + event->name = name; + event->attribute = attribute; + event->sig = sig; + return event; + } +}; + +} // namespace wasm + +#endif // wasm_wasm_builder_h diff --git a/binaryen/src/wasm-debug.h b/binaryen/src/wasm-debug.h new file mode 100644 --- /dev/null +++ b/binaryen/src/wasm-debug.h @@ -0,0 +1,48 @@ +/* + * Copyright 2019 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// Comprehensive debug info support (beyond source maps). +// + +#ifndef wasm_wasm_debug_h +#define wasm_wasm_debug_h + +#include + +#include "wasm.h" + +namespace wasm { + +namespace Debug { + +bool isDWARFSection(Name name); + +bool hasDWARFSections(const Module& wasm); + +// Dump the DWARF sections to stdout. +void dumpDWARF(const Module& wasm); + +// Update the DWARF sections. +void writeDWARFSections(Module& wasm, const BinaryLocations& newLocations); + +} // namespace Debug + +} // namespace wasm + +#undef DEBUG_TYPE + +#endif // wasm_wasm_debug_h diff --git a/binaryen/src/wasm-emscripten.h b/binaryen/src/wasm-emscripten.h new file mode 100644 --- /dev/null +++ b/binaryen/src/wasm-emscripten.h @@ -0,0 +1,76 @@ +/* + * Copyright 2016 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef wasm_wasm_emscripten_h +#define wasm_wasm_emscripten_h + +#include "support/file.h" +#include "wasm-builder.h" +#include "wasm.h" + +namespace wasm { + +Global* getStackPointerGlobal(Module& wasm); + +// Class which modifies a wasm module for use with emscripten. Generates +// runtime functions and emits metadata. +class EmscriptenGlueGenerator { +public: + EmscriptenGlueGenerator(Module& wasm, Address stackPointerOffset = Address(0)) + : wasm(wasm), builder(wasm), stackPointerOffset(stackPointerOffset), + useStackPointerGlobal(stackPointerOffset == 0) {} + + Function* generateAssignGOTEntriesFunction(); + void generatePostInstantiateFunction(); + + // Remove the import of a mutable __stack_pointer and instead initialize the + // stack pointer from an immutable import. + void internalizeStackPointerGlobal(); + + std::string + generateEmscriptenMetadata(Address staticBump, + std::vector const& initializerFunctions); + + void fixInvokeFunctionNames(); + + // clang uses name mangling to rename the argc/argv form of main to + // __main_argc_argv. Emscripten in non-standalone mode expects that function + // to be exported as main. This function renames __main_argc_argv to main + // as expected by emscripten. + void renameMainArgcArgv(); + + // Emits the data segments to a file. The file contains data from address base + // onwards (we must pass in base, as we can't tell it from the wasm - the + // first segment may start after a run of zeros, but we need those zeros in + // the file). + void separateDataSegments(Output* outfile, Address base); + + bool standalone = false; + bool sideModule = false; + bool minimizeWasmChanges = false; + bool noDynCalls = false; + bool onlyI64DynCalls = false; + +private: + Module& wasm; + Builder builder; + Address stackPointerOffset; + bool useStackPointerGlobal; +}; + +} // namespace wasm + +#endif // wasm_wasm_emscripten_h diff --git a/binaryen/src/wasm-features.h b/binaryen/src/wasm-features.h new file mode 100644 --- /dev/null +++ b/binaryen/src/wasm-features.h @@ -0,0 +1,146 @@ +/* + * Copyright 2019 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef wasm_features_h +#define wasm_features_h + +#include +#include + +#include "compiler-support.h" +#include "support/utilities.h" + +struct FeatureSet { + enum Feature : uint32_t { + MVP = 0, + Atomics = 1 << 0, + MutableGlobals = 1 << 1, + TruncSat = 1 << 2, + SIMD = 1 << 3, + BulkMemory = 1 << 4, + SignExt = 1 << 5, + ExceptionHandling = 1 << 6, + TailCall = 1 << 7, + ReferenceTypes = 1 << 8, + Multivalue = 1 << 9, + GC = 1 << 10, + Memory64 = 1 << 11, + All = (1 << 12) - 1 + }; + + static std::string toString(Feature f) { + switch (f) { + case Atomics: + return "threads"; + case MutableGlobals: + return "mutable-globals"; + case TruncSat: + return "nontrapping-float-to-int"; + case SIMD: + return "simd"; + case BulkMemory: + return "bulk-memory"; + case SignExt: + return "sign-ext"; + case ExceptionHandling: + return "exception-handling"; + case TailCall: + return "tail-call"; + case ReferenceTypes: + return "reference-types"; + case Multivalue: + return "multivalue"; + case GC: + return "gc"; + case Memory64: + return "memory64"; + default: + WASM_UNREACHABLE("unexpected feature"); + } + } + + FeatureSet() : features(MVP) {} + FeatureSet(uint32_t features) : features(features) {} + operator uint32_t() const { return features; } + + bool isMVP() const { return features == MVP; } + bool has(FeatureSet f) { return (features & f) == f; } + bool hasAtomics() const { return (features & Atomics) != 0; } + bool hasMutableGlobals() const { return (features & MutableGlobals) != 0; } + bool hasTruncSat() const { return (features & TruncSat) != 0; } + bool hasSIMD() const { return (features & SIMD) != 0; } + bool hasBulkMemory() const { return (features & BulkMemory) != 0; } + bool hasSignExt() const { return (features & SignExt) != 0; } + bool hasExceptionHandling() const { + return (features & ExceptionHandling) != 0; + } + bool hasTailCall() const { return (features & TailCall) != 0; } + bool hasReferenceTypes() const { return (features & ReferenceTypes) != 0; } + bool hasMultivalue() const { return (features & Multivalue) != 0; } + bool hasGC() const { return (features & GC) != 0; } + bool hasMemory64() const { return (features & Memory64) != 0; } + bool hasAll() const { return (features & All) != 0; } + + void makeMVP() { features = MVP; } + void set(FeatureSet f, bool v = true) { + features = v ? (features | f) : (features & ~f); + } + void setAtomics(bool v = true) { set(Atomics, v); } + void setMutableGlobals(bool v = true) { set(MutableGlobals, v); } + void setTruncSat(bool v = true) { set(TruncSat, v); } + void setSIMD(bool v = true) { set(SIMD, v); } + void setBulkMemory(bool v = true) { set(BulkMemory, v); } + void setSignExt(bool v = true) { set(SignExt, v); } + void setExceptionHandling(bool v = true) { set(ExceptionHandling, v); } + void setTailCall(bool v = true) { set(TailCall, v); } + void setReferenceTypes(bool v = true) { set(ReferenceTypes, v); } + void setMultivalue(bool v = true) { set(Multivalue, v); } + void setGC(bool v = true) { set(GC, v); } + void setMemory64(bool v = true) { set(Memory64, v); } + void setAll(bool v = true) { features = v ? All : MVP; } + + void enable(const FeatureSet& other) { features |= other.features; } + void disable(const FeatureSet& other) { + features = features & ~other.features & All; + } + + template void iterFeatures(F f) { + for (uint32_t feature = MVP + 1; feature < All; feature <<= 1) { + if (has(feature)) { + f(static_cast(feature)); + } + } + } + + bool operator<=(const FeatureSet& other) const { + return !(features & ~other.features); + } + + bool operator==(const FeatureSet& other) const { + return *this <= other && other <= *this; + } + + bool operator!=(const FeatureSet& other) const { return !(*this == other); } + + FeatureSet& operator|=(const FeatureSet& other) { + features |= other.features; + return *this; + } + + uint32_t features; +}; + +#endif // wasm_features_h diff --git a/binaryen/src/wasm-interpreter.h b/binaryen/src/wasm-interpreter.h new file mode 100644 --- /dev/null +++ b/binaryen/src/wasm-interpreter.h @@ -0,0 +1,2765 @@ +/* + * Copyright 2015 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// Simple WebAssembly interpreter. This operates directly on the AST, +// for simplicity and clarity. A goal is for it to be possible for +// people to read this code and understand WebAssembly semantics. +// + +#ifndef wasm_wasm_interpreter_h +#define wasm_wasm_interpreter_h + +#include +#include +#include + +#include "ir/module-utils.h" +#include "support/bits.h" +#include "support/safe_integer.h" +#include "wasm-builder.h" +#include "wasm-traversal.h" +#include "wasm.h" + +#ifdef WASM_INTERPRETER_DEBUG +#include "wasm-printing.h" +#endif + +namespace wasm { + +struct WasmException { + WasmException(Literal exn) : exn(exn) {} + Literal exn; +}; + +using namespace cashew; + +// Utilities + +extern Name WASM, RETURN_FLOW, NONCONSTANT_FLOW; + +// Stuff that flows around during executing expressions: a literal, or a change +// in control flow. +class Flow { +public: + Flow() : values() {} + Flow(Literal value) : values{value} { assert(value.type.isConcrete()); } + Flow(Literals& values) : values(values) {} + Flow(Literals&& values) : values(std::move(values)) {} + Flow(Name breakTo) : values(), breakTo(breakTo) {} + + Literals values; + Name breakTo; // if non-null, a break is going on + + // A helper function for the common case where there is only one value + const Literal& getSingleValue() { + assert(values.size() == 1); + return values[0]; + } + + Type getType() { return values.getType(); } + + Expression* getConstExpression(Module& module) { + assert(values.size() > 0); + Builder builder(module); + return builder.makeConstantExpression(values); + } + + bool breaking() { return breakTo.is(); } + + void clearIf(Name target) { + if (breakTo == target) { + breakTo.clear(); + } + } + + friend std::ostream& operator<<(std::ostream& o, const Flow& flow) { + o << "(flow " << (flow.breakTo.is() ? flow.breakTo.str : "-") << " : {"; + for (size_t i = 0; i < flow.values.size(); ++i) { + if (i > 0) { + o << ", "; + } + o << flow.values[i]; + } + o << "})"; + return o; + } +}; + +// A list of literals, for function calls +typedef std::vector LiteralList; + +// Debugging helpers +#ifdef WASM_INTERPRETER_DEBUG +class Indenter { + static int indentLevel; + + const char* entryName; + +public: + Indenter(const char* entry); + ~Indenter(); + + static void print(); +}; + +#define NOTE_ENTER(x) \ + Indenter _int_blah(x); \ + { \ + Indenter::print(); \ + std::cout << "visit " << x << " : " << curr << "\n"; \ + } +#define NOTE_ENTER_(x) \ + Indenter _int_blah(x); \ + { \ + Indenter::print(); \ + std::cout << "visit " << x << "\n"; \ + } +#define NOTE_NAME(p0) \ + { \ + Indenter::print(); \ + std::cout << "name " << '(' << Name(p0) << ")\n"; \ + } +#define NOTE_EVAL1(p0) \ + { \ + Indenter::print(); \ + std::cout << "eval " #p0 " (" << p0 << ")\n"; \ + } +#define NOTE_EVAL2(p0, p1) \ + { \ + Indenter::print(); \ + std::cout << "eval " #p0 " (" << p0 << "), " #p1 " (" << p1 << ")\n"; \ + } +#else // WASM_INTERPRETER_DEBUG +#define NOTE_ENTER(x) +#define NOTE_ENTER_(x) +#define NOTE_NAME(p0) +#define NOTE_EVAL1(p0) +#define NOTE_EVAL2(p0, p1) +#endif // WASM_INTERPRETER_DEBUG + +// Execute an expression +template +class ExpressionRunner : public OverriddenVisitor { +protected: + // Maximum depth before giving up. + Index maxDepth; + Index depth = 0; + + // Maximum iterations before giving up on a loop. + Index maxLoopIterations; + + Flow generateArguments(const ExpressionList& operands, + LiteralList& arguments) { + NOTE_ENTER_("generateArguments"); + arguments.reserve(operands.size()); + for (auto expression : operands) { + Flow flow = this->visit(expression); + if (flow.breaking()) { + return flow; + } + NOTE_EVAL1(flow.values); + arguments.push_back(flow.getSingleValue()); + } + return Flow(); + } + +public: + // Indicates no limit of maxDepth or maxLoopIterations. + static const Index NO_LIMIT = 0; + + ExpressionRunner(Index maxDepth = NO_LIMIT, + Index maxLoopIterations = NO_LIMIT) + : maxDepth(maxDepth), maxLoopIterations(maxLoopIterations) {} + + Flow visit(Expression* curr) { + depth++; + if (maxDepth != NO_LIMIT && depth > maxDepth) { + trap("interpreter recursion limit"); + } + auto ret = OverriddenVisitor::visit(curr); + if (!ret.breaking()) { + Type type = ret.getType(); + if (type.isConcrete() || curr->type.isConcrete()) { +#if 1 // def WASM_INTERPRETER_DEBUG + if (!Type::isSubType(type, curr->type)) { + std::cerr << "expected " << curr->type << ", seeing " << type + << " from\n" + << curr << '\n'; + } +#endif + assert(Type::isSubType(type, curr->type)); + } + } + depth--; + return ret; + } + + Flow visitBlock(Block* curr) { + NOTE_ENTER("Block"); + // special-case Block, because Block nesting (in their first element) can be + // incredibly deep + std::vector stack; + stack.push_back(curr); + while (curr->list.size() > 0 && curr->list[0]->is()) { + curr = curr->list[0]->cast(); + stack.push_back(curr); + } + Flow flow; + auto* top = stack.back(); + while (stack.size() > 0) { + curr = stack.back(); + stack.pop_back(); + if (flow.breaking()) { + flow.clearIf(curr->name); + continue; + } + auto& list = curr->list; + for (size_t i = 0; i < list.size(); i++) { + if (curr != top && i == 0) { + // one of the block recursions we already handled + continue; + } + flow = visit(list[i]); + if (flow.breaking()) { + flow.clearIf(curr->name); + break; + } + } + } + return flow; + } + Flow visitIf(If* curr) { + NOTE_ENTER("If"); + Flow flow = visit(curr->condition); + if (flow.breaking()) { + return flow; + } + NOTE_EVAL1(flow.values); + if (flow.getSingleValue().geti32()) { + Flow flow = visit(curr->ifTrue); + if (!flow.breaking() && !curr->ifFalse) { + flow = Flow(); // if_else returns a value, but if does not + } + return flow; + } + if (curr->ifFalse) { + return visit(curr->ifFalse); + } + return Flow(); + } + Flow visitLoop(Loop* curr) { + NOTE_ENTER("Loop"); + Index loopCount = 0; + while (1) { + Flow flow = visit(curr->body); + if (flow.breaking()) { + if (flow.breakTo == curr->name) { + if (maxLoopIterations != NO_LIMIT && + ++loopCount >= maxLoopIterations) { + return Flow(NONCONSTANT_FLOW); + } + continue; // lol + } + } + // loop does not loop automatically, only continue achieves that + return flow; + } + } + Flow visitBreak(Break* curr) { + NOTE_ENTER("Break"); + bool condition = true; + Flow flow; + if (curr->value) { + flow = visit(curr->value); + if (flow.breaking()) { + return flow; + } + } + if (curr->condition) { + Flow conditionFlow = visit(curr->condition); + if (conditionFlow.breaking()) { + return conditionFlow; + } + condition = conditionFlow.getSingleValue().getInteger() != 0; + if (!condition) { + return flow; + } + } + flow.breakTo = curr->name; + return flow; + } + Flow visitSwitch(Switch* curr) { + NOTE_ENTER("Switch"); + Flow flow; + Literals values; + if (curr->value) { + flow = visit(curr->value); + if (flow.breaking()) { + return flow; + } + values = flow.values; + } + flow = visit(curr->condition); + if (flow.breaking()) { + return flow; + } + int64_t index = flow.getSingleValue().getInteger(); + Name target = curr->default_; + if (index >= 0 && (size_t)index < curr->targets.size()) { + target = curr->targets[(size_t)index]; + } + flow.breakTo = target; + flow.values = values; + return flow; + } + + Flow visitConst(Const* curr) { + NOTE_ENTER("Const"); + NOTE_EVAL1(curr->value); + return Flow(curr->value); // heh + } + + // Unary and Binary nodes, the core math computations. We mostly just + // delegate to the Literal::* methods, except we handle traps here. + + Flow visitUnary(Unary* curr) { + NOTE_ENTER("Unary"); + Flow flow = visit(curr->value); + if (flow.breaking()) { + return flow; + } + Literal value = flow.getSingleValue(); + NOTE_EVAL1(value); + switch (curr->op) { + case ClzInt32: + case ClzInt64: + return value.countLeadingZeroes(); + case CtzInt32: + case CtzInt64: + return value.countTrailingZeroes(); + case PopcntInt32: + case PopcntInt64: + return value.popCount(); + case EqZInt32: + case EqZInt64: + return value.eqz(); + case ReinterpretInt32: + return value.castToF32(); + case ReinterpretInt64: + return value.castToF64(); + case ExtendSInt32: + return value.extendToSI64(); + case ExtendUInt32: + return value.extendToUI64(); + case WrapInt64: + return value.wrapToI32(); + case ConvertUInt32ToFloat32: + case ConvertUInt64ToFloat32: + return value.convertUIToF32(); + case ConvertUInt32ToFloat64: + case ConvertUInt64ToFloat64: + return value.convertUIToF64(); + case ConvertSInt32ToFloat32: + case ConvertSInt64ToFloat32: + return value.convertSIToF32(); + case ConvertSInt32ToFloat64: + case ConvertSInt64ToFloat64: + return value.convertSIToF64(); + case ExtendS8Int32: + case ExtendS8Int64: + return value.extendS8(); + case ExtendS16Int32: + case ExtendS16Int64: + return value.extendS16(); + case ExtendS32Int64: + return value.extendS32(); + + case NegFloat32: + case NegFloat64: + return value.neg(); + case AbsFloat32: + case AbsFloat64: + return value.abs(); + case CeilFloat32: + case CeilFloat64: + return value.ceil(); + case FloorFloat32: + case FloorFloat64: + return value.floor(); + case TruncFloat32: + case TruncFloat64: + return value.trunc(); + case NearestFloat32: + case NearestFloat64: + return value.nearbyint(); + case SqrtFloat32: + case SqrtFloat64: + return value.sqrt(); + case TruncSFloat32ToInt32: + case TruncSFloat64ToInt32: + case TruncSFloat32ToInt64: + case TruncSFloat64ToInt64: + return truncSFloat(curr, value); + case TruncUFloat32ToInt32: + case TruncUFloat64ToInt32: + case TruncUFloat32ToInt64: + case TruncUFloat64ToInt64: + return truncUFloat(curr, value); + case TruncSatSFloat32ToInt32: + case TruncSatSFloat64ToInt32: + return value.truncSatToSI32(); + case TruncSatSFloat32ToInt64: + case TruncSatSFloat64ToInt64: + return value.truncSatToSI64(); + case TruncSatUFloat32ToInt32: + case TruncSatUFloat64ToInt32: + return value.truncSatToUI32(); + case TruncSatUFloat32ToInt64: + case TruncSatUFloat64ToInt64: + return value.truncSatToUI64(); + case ReinterpretFloat32: + return value.castToI32(); + case PromoteFloat32: + return value.extendToF64(); + case ReinterpretFloat64: + return value.castToI64(); + case DemoteFloat64: + return value.demote(); + case SplatVecI8x16: + return value.splatI8x16(); + case SplatVecI16x8: + return value.splatI16x8(); + case SplatVecI32x4: + return value.splatI32x4(); + case SplatVecI64x2: + return value.splatI64x2(); + case SplatVecF32x4: + return value.splatF32x4(); + case SplatVecF64x2: + return value.splatF64x2(); + case NotVec128: + return value.notV128(); + case AbsVecI8x16: + return value.absI8x16(); + case NegVecI8x16: + return value.negI8x16(); + case AnyTrueVecI8x16: + return value.anyTrueI8x16(); + case AllTrueVecI8x16: + return value.allTrueI8x16(); + case BitmaskVecI8x16: + return value.bitmaskI8x16(); + case AbsVecI16x8: + return value.absI16x8(); + case NegVecI16x8: + return value.negI16x8(); + case AnyTrueVecI16x8: + return value.anyTrueI16x8(); + case AllTrueVecI16x8: + return value.allTrueI16x8(); + case BitmaskVecI16x8: + return value.bitmaskI16x8(); + case AbsVecI32x4: + return value.absI32x4(); + case NegVecI32x4: + return value.negI32x4(); + case AnyTrueVecI32x4: + return value.anyTrueI32x4(); + case AllTrueVecI32x4: + return value.allTrueI32x4(); + case BitmaskVecI32x4: + return value.bitmaskI32x4(); + case NegVecI64x2: + return value.negI64x2(); + case AnyTrueVecI64x2: + return value.anyTrueI64x2(); + case AllTrueVecI64x2: + return value.allTrueI64x2(); + case AbsVecF32x4: + return value.absF32x4(); + case NegVecF32x4: + return value.negF32x4(); + case SqrtVecF32x4: + return value.sqrtF32x4(); + case CeilVecF32x4: + return value.ceilF32x4(); + case FloorVecF32x4: + return value.floorF32x4(); + case TruncVecF32x4: + return value.truncF32x4(); + case NearestVecF32x4: + return value.nearestF32x4(); + case AbsVecF64x2: + return value.absF64x2(); + case NegVecF64x2: + return value.negF64x2(); + case SqrtVecF64x2: + return value.sqrtF64x2(); + case CeilVecF64x2: + return value.ceilF64x2(); + case FloorVecF64x2: + return value.floorF64x2(); + case TruncVecF64x2: + return value.truncF64x2(); + case NearestVecF64x2: + return value.nearestF64x2(); + case TruncSatSVecF32x4ToVecI32x4: + return value.truncSatToSI32x4(); + case TruncSatUVecF32x4ToVecI32x4: + return value.truncSatToUI32x4(); + case TruncSatSVecF64x2ToVecI64x2: + return value.truncSatToSI64x2(); + case TruncSatUVecF64x2ToVecI64x2: + return value.truncSatToUI64x2(); + case ConvertSVecI32x4ToVecF32x4: + return value.convertSToF32x4(); + case ConvertUVecI32x4ToVecF32x4: + return value.convertUToF32x4(); + case ConvertSVecI64x2ToVecF64x2: + return value.convertSToF64x2(); + case ConvertUVecI64x2ToVecF64x2: + return value.convertUToF64x2(); + case WidenLowSVecI8x16ToVecI16x8: + return value.widenLowSToVecI16x8(); + case WidenHighSVecI8x16ToVecI16x8: + return value.widenHighSToVecI16x8(); + case WidenLowUVecI8x16ToVecI16x8: + return value.widenLowUToVecI16x8(); + case WidenHighUVecI8x16ToVecI16x8: + return value.widenHighUToVecI16x8(); + case WidenLowSVecI16x8ToVecI32x4: + return value.widenLowSToVecI32x4(); + case WidenHighSVecI16x8ToVecI32x4: + return value.widenHighSToVecI32x4(); + case WidenLowUVecI16x8ToVecI32x4: + return value.widenLowUToVecI32x4(); + case WidenHighUVecI16x8ToVecI32x4: + return value.widenHighUToVecI32x4(); + case InvalidUnary: + WASM_UNREACHABLE("invalid unary op"); + } + WASM_UNREACHABLE("invalid op"); + } + Flow visitBinary(Binary* curr) { + NOTE_ENTER("Binary"); + Flow flow = visit(curr->left); + if (flow.breaking()) { + return flow; + } + Literal left = flow.getSingleValue(); + flow = visit(curr->right); + if (flow.breaking()) { + return flow; + } + Literal right = flow.getSingleValue(); + NOTE_EVAL2(left, right); + assert(curr->left->type.isConcrete() ? left.type == curr->left->type + : true); + assert(curr->right->type.isConcrete() ? right.type == curr->right->type + : true); + switch (curr->op) { + case AddInt32: + case AddInt64: + case AddFloat32: + case AddFloat64: + return left.add(right); + case SubInt32: + case SubInt64: + case SubFloat32: + case SubFloat64: + return left.sub(right); + case MulInt32: + case MulInt64: + case MulFloat32: + case MulFloat64: + return left.mul(right); + case DivSInt32: { + if (right.getInteger() == 0) { + trap("i32.div_s by 0"); + } + if (left.getInteger() == std::numeric_limits::min() && + right.getInteger() == -1) { + trap("i32.div_s overflow"); // signed division overflow + } + return left.divS(right); + } + case DivUInt32: { + if (right.getInteger() == 0) { + trap("i32.div_u by 0"); + } + return left.divU(right); + } + case RemSInt32: { + if (right.getInteger() == 0) { + trap("i32.rem_s by 0"); + } + if (left.getInteger() == std::numeric_limits::min() && + right.getInteger() == -1) { + return Literal(int32_t(0)); + } + return left.remS(right); + } + case RemUInt32: { + if (right.getInteger() == 0) { + trap("i32.rem_u by 0"); + } + return left.remU(right); + } + case DivSInt64: { + if (right.getInteger() == 0) { + trap("i64.div_s by 0"); + } + if (left.getInteger() == LLONG_MIN && right.getInteger() == -1LL) { + trap("i64.div_s overflow"); // signed division overflow + } + return left.divS(right); + } + case DivUInt64: { + if (right.getInteger() == 0) { + trap("i64.div_u by 0"); + } + return left.divU(right); + } + case RemSInt64: { + if (right.getInteger() == 0) { + trap("i64.rem_s by 0"); + } + if (left.getInteger() == LLONG_MIN && right.getInteger() == -1LL) { + return Literal(int64_t(0)); + } + return left.remS(right); + } + case RemUInt64: { + if (right.getInteger() == 0) { + trap("i64.rem_u by 0"); + } + return left.remU(right); + } + case DivFloat32: + case DivFloat64: + return left.div(right); + case AndInt32: + case AndInt64: + return left.and_(right); + case OrInt32: + case OrInt64: + return left.or_(right); + case XorInt32: + case XorInt64: + return left.xor_(right); + case ShlInt32: + case ShlInt64: + return left.shl(right); + case ShrUInt32: + case ShrUInt64: + return left.shrU(right); + case ShrSInt32: + case ShrSInt64: + return left.shrS(right); + case RotLInt32: + case RotLInt64: + return left.rotL(right); + case RotRInt32: + case RotRInt64: + return left.rotR(right); + + case EqInt32: + case EqInt64: + case EqFloat32: + case EqFloat64: + return left.eq(right); + case NeInt32: + case NeInt64: + case NeFloat32: + case NeFloat64: + return left.ne(right); + case LtSInt32: + case LtSInt64: + return left.ltS(right); + case LtUInt32: + case LtUInt64: + return left.ltU(right); + case LeSInt32: + case LeSInt64: + return left.leS(right); + case LeUInt32: + case LeUInt64: + return left.leU(right); + case GtSInt32: + case GtSInt64: + return left.gtS(right); + case GtUInt32: + case GtUInt64: + return left.gtU(right); + case GeSInt32: + case GeSInt64: + return left.geS(right); + case GeUInt32: + case GeUInt64: + return left.geU(right); + case LtFloat32: + case LtFloat64: + return left.lt(right); + case LeFloat32: + case LeFloat64: + return left.le(right); + case GtFloat32: + case GtFloat64: + return left.gt(right); + case GeFloat32: + case GeFloat64: + return left.ge(right); + + case CopySignFloat32: + case CopySignFloat64: + return left.copysign(right); + case MinFloat32: + case MinFloat64: + return left.min(right); + case MaxFloat32: + case MaxFloat64: + return left.max(right); + + case EqVecI8x16: + return left.eqI8x16(right); + case NeVecI8x16: + return left.neI8x16(right); + case LtSVecI8x16: + return left.ltSI8x16(right); + case LtUVecI8x16: + return left.ltUI8x16(right); + case GtSVecI8x16: + return left.gtSI8x16(right); + case GtUVecI8x16: + return left.gtUI8x16(right); + case LeSVecI8x16: + return left.leSI8x16(right); + case LeUVecI8x16: + return left.leUI8x16(right); + case GeSVecI8x16: + return left.geSI8x16(right); + case GeUVecI8x16: + return left.geUI8x16(right); + case EqVecI16x8: + return left.eqI16x8(right); + case NeVecI16x8: + return left.neI16x8(right); + case LtSVecI16x8: + return left.ltSI16x8(right); + case LtUVecI16x8: + return left.ltUI16x8(right); + case GtSVecI16x8: + return left.gtSI16x8(right); + case GtUVecI16x8: + return left.gtUI16x8(right); + case LeSVecI16x8: + return left.leSI16x8(right); + case LeUVecI16x8: + return left.leUI16x8(right); + case GeSVecI16x8: + return left.geSI16x8(right); + case GeUVecI16x8: + return left.geUI16x8(right); + case EqVecI32x4: + return left.eqI32x4(right); + case NeVecI32x4: + return left.neI32x4(right); + case LtSVecI32x4: + return left.ltSI32x4(right); + case LtUVecI32x4: + return left.ltUI32x4(right); + case GtSVecI32x4: + return left.gtSI32x4(right); + case GtUVecI32x4: + return left.gtUI32x4(right); + case LeSVecI32x4: + return left.leSI32x4(right); + case LeUVecI32x4: + return left.leUI32x4(right); + case GeSVecI32x4: + return left.geSI32x4(right); + case GeUVecI32x4: + return left.geUI32x4(right); + case EqVecF32x4: + return left.eqF32x4(right); + case NeVecF32x4: + return left.neF32x4(right); + case LtVecF32x4: + return left.ltF32x4(right); + case GtVecF32x4: + return left.gtF32x4(right); + case LeVecF32x4: + return left.leF32x4(right); + case GeVecF32x4: + return left.geF32x4(right); + case EqVecF64x2: + return left.eqF64x2(right); + case NeVecF64x2: + return left.neF64x2(right); + case LtVecF64x2: + return left.ltF64x2(right); + case GtVecF64x2: + return left.gtF64x2(right); + case LeVecF64x2: + return left.leF64x2(right); + case GeVecF64x2: + return left.geF64x2(right); + + case AndVec128: + return left.andV128(right); + case OrVec128: + return left.orV128(right); + case XorVec128: + return left.xorV128(right); + case AndNotVec128: + return left.andV128(right.notV128()); + + case AddVecI8x16: + return left.addI8x16(right); + case AddSatSVecI8x16: + return left.addSaturateSI8x16(right); + case AddSatUVecI8x16: + return left.addSaturateUI8x16(right); + case SubVecI8x16: + return left.subI8x16(right); + case SubSatSVecI8x16: + return left.subSaturateSI8x16(right); + case SubSatUVecI8x16: + return left.subSaturateUI8x16(right); + case MulVecI8x16: + return left.mulI8x16(right); + case MinSVecI8x16: + return left.minSI8x16(right); + case MinUVecI8x16: + return left.minUI8x16(right); + case MaxSVecI8x16: + return left.maxSI8x16(right); + case MaxUVecI8x16: + return left.maxUI8x16(right); + case AvgrUVecI8x16: + return left.avgrUI8x16(right); + case AddVecI16x8: + return left.addI16x8(right); + case AddSatSVecI16x8: + return left.addSaturateSI16x8(right); + case AddSatUVecI16x8: + return left.addSaturateUI16x8(right); + case SubVecI16x8: + return left.subI16x8(right); + case SubSatSVecI16x8: + return left.subSaturateSI16x8(right); + case SubSatUVecI16x8: + return left.subSaturateUI16x8(right); + case MulVecI16x8: + return left.mulI16x8(right); + case MinSVecI16x8: + return left.minSI16x8(right); + case MinUVecI16x8: + return left.minUI16x8(right); + case MaxSVecI16x8: + return left.maxSI16x8(right); + case MaxUVecI16x8: + return left.maxUI16x8(right); + case AvgrUVecI16x8: + return left.avgrUI16x8(right); + case AddVecI32x4: + return left.addI32x4(right); + case SubVecI32x4: + return left.subI32x4(right); + case MulVecI32x4: + return left.mulI32x4(right); + case MinSVecI32x4: + return left.minSI32x4(right); + case MinUVecI32x4: + return left.minUI32x4(right); + case MaxSVecI32x4: + return left.maxSI32x4(right); + case MaxUVecI32x4: + return left.maxUI32x4(right); + case DotSVecI16x8ToVecI32x4: + return left.dotSI16x8toI32x4(right); + case AddVecI64x2: + return left.addI64x2(right); + case SubVecI64x2: + return left.subI64x2(right); + case MulVecI64x2: + return left.mulI64x2(right); + + case AddVecF32x4: + return left.addF32x4(right); + case SubVecF32x4: + return left.subF32x4(right); + case MulVecF32x4: + return left.mulF32x4(right); + case DivVecF32x4: + return left.divF32x4(right); + case MinVecF32x4: + return left.minF32x4(right); + case MaxVecF32x4: + return left.maxF32x4(right); + case PMinVecF32x4: + return left.pminF32x4(right); + case PMaxVecF32x4: + return left.pmaxF32x4(right); + case AddVecF64x2: + return left.addF64x2(right); + case SubVecF64x2: + return left.subF64x2(right); + case MulVecF64x2: + return left.mulF64x2(right); + case DivVecF64x2: + return left.divF64x2(right); + case MinVecF64x2: + return left.minF64x2(right); + case MaxVecF64x2: + return left.maxF64x2(right); + case PMinVecF64x2: + return left.pminF64x2(right); + case PMaxVecF64x2: + return left.pmaxF64x2(right); + + case NarrowSVecI16x8ToVecI8x16: + return left.narrowSToVecI8x16(right); + case NarrowUVecI16x8ToVecI8x16: + return left.narrowUToVecI8x16(right); + case NarrowSVecI32x4ToVecI16x8: + return left.narrowSToVecI16x8(right); + case NarrowUVecI32x4ToVecI16x8: + return left.narrowUToVecI16x8(right); + + case SwizzleVec8x16: + return left.swizzleVec8x16(right); + + case InvalidBinary: + WASM_UNREACHABLE("invalid binary op"); + } + WASM_UNREACHABLE("invalid op"); + } + Flow visitSIMDExtract(SIMDExtract* curr) { + NOTE_ENTER("SIMDExtract"); + Flow flow = this->visit(curr->vec); + if (flow.breaking()) { + return flow; + } + Literal vec = flow.getSingleValue(); + switch (curr->op) { + case ExtractLaneSVecI8x16: + return vec.extractLaneSI8x16(curr->index); + case ExtractLaneUVecI8x16: + return vec.extractLaneUI8x16(curr->index); + case ExtractLaneSVecI16x8: + return vec.extractLaneSI16x8(curr->index); + case ExtractLaneUVecI16x8: + return vec.extractLaneUI16x8(curr->index); + case ExtractLaneVecI32x4: + return vec.extractLaneI32x4(curr->index); + case ExtractLaneVecI64x2: + return vec.extractLaneI64x2(curr->index); + case ExtractLaneVecF32x4: + return vec.extractLaneF32x4(curr->index); + case ExtractLaneVecF64x2: + return vec.extractLaneF64x2(curr->index); + } + WASM_UNREACHABLE("invalid op"); + } + Flow visitSIMDReplace(SIMDReplace* curr) { + NOTE_ENTER("SIMDReplace"); + Flow flow = this->visit(curr->vec); + if (flow.breaking()) { + return flow; + } + Literal vec = flow.getSingleValue(); + flow = this->visit(curr->value); + if (flow.breaking()) { + return flow; + } + Literal value = flow.getSingleValue(); + switch (curr->op) { + case ReplaceLaneVecI8x16: + return vec.replaceLaneI8x16(value, curr->index); + case ReplaceLaneVecI16x8: + return vec.replaceLaneI16x8(value, curr->index); + case ReplaceLaneVecI32x4: + return vec.replaceLaneI32x4(value, curr->index); + case ReplaceLaneVecI64x2: + return vec.replaceLaneI64x2(value, curr->index); + case ReplaceLaneVecF32x4: + return vec.replaceLaneF32x4(value, curr->index); + case ReplaceLaneVecF64x2: + return vec.replaceLaneF64x2(value, curr->index); + } + WASM_UNREACHABLE("invalid op"); + } + Flow visitSIMDShuffle(SIMDShuffle* curr) { + NOTE_ENTER("SIMDShuffle"); + Flow flow = this->visit(curr->left); + if (flow.breaking()) { + return flow; + } + Literal left = flow.getSingleValue(); + flow = this->visit(curr->right); + if (flow.breaking()) { + return flow; + } + Literal right = flow.getSingleValue(); + return left.shuffleV8x16(right, curr->mask); + } + Flow visitSIMDTernary(SIMDTernary* curr) { + NOTE_ENTER("SIMDBitselect"); + Flow flow = this->visit(curr->a); + if (flow.breaking()) { + return flow; + } + Literal a = flow.getSingleValue(); + flow = this->visit(curr->b); + if (flow.breaking()) { + return flow; + } + Literal b = flow.getSingleValue(); + flow = this->visit(curr->c); + if (flow.breaking()) { + return flow; + } + Literal c = flow.getSingleValue(); + switch (curr->op) { + case Bitselect: + return c.bitselectV128(a, b); + default: + // TODO: implement qfma/qfms + WASM_UNREACHABLE("not implemented"); + } + } + Flow visitSIMDShift(SIMDShift* curr) { + NOTE_ENTER("SIMDShift"); + Flow flow = this->visit(curr->vec); + if (flow.breaking()) { + return flow; + } + Literal vec = flow.getSingleValue(); + flow = this->visit(curr->shift); + if (flow.breaking()) { + return flow; + } + Literal shift = flow.getSingleValue(); + switch (curr->op) { + case ShlVecI8x16: + return vec.shlI8x16(shift); + case ShrSVecI8x16: + return vec.shrSI8x16(shift); + case ShrUVecI8x16: + return vec.shrUI8x16(shift); + case ShlVecI16x8: + return vec.shlI16x8(shift); + case ShrSVecI16x8: + return vec.shrSI16x8(shift); + case ShrUVecI16x8: + return vec.shrUI16x8(shift); + case ShlVecI32x4: + return vec.shlI32x4(shift); + case ShrSVecI32x4: + return vec.shrSI32x4(shift); + case ShrUVecI32x4: + return vec.shrUI32x4(shift); + case ShlVecI64x2: + return vec.shlI64x2(shift); + case ShrSVecI64x2: + return vec.shrSI64x2(shift); + case ShrUVecI64x2: + return vec.shrUI64x2(shift); + } + WASM_UNREACHABLE("invalid op"); + } + Flow visitSelect(Select* curr) { + NOTE_ENTER("Select"); + Flow ifTrue = visit(curr->ifTrue); + if (ifTrue.breaking()) { + return ifTrue; + } + Flow ifFalse = visit(curr->ifFalse); + if (ifFalse.breaking()) { + return ifFalse; + } + Flow condition = visit(curr->condition); + if (condition.breaking()) { + return condition; + } + NOTE_EVAL1(condition.getSingleValue()); + return condition.getSingleValue().geti32() ? ifTrue : ifFalse; // ;-) + } + Flow visitDrop(Drop* curr) { + NOTE_ENTER("Drop"); + Flow value = visit(curr->value); + if (value.breaking()) { + return value; + } + return Flow(); + } + Flow visitReturn(Return* curr) { + NOTE_ENTER("Return"); + Flow flow; + if (curr->value) { + flow = visit(curr->value); + if (flow.breaking()) { + return flow; + } + NOTE_EVAL1(flow.getSingleValue()); + } + flow.breakTo = RETURN_FLOW; + return flow; + } + Flow visitNop(Nop* curr) { + NOTE_ENTER("Nop"); + return Flow(); + } + Flow visitUnreachable(Unreachable* curr) { + NOTE_ENTER("Unreachable"); + trap("unreachable"); + WASM_UNREACHABLE("unreachable"); + } + + Literal truncSFloat(Unary* curr, Literal value) { + double val = value.getFloat(); + if (std::isnan(val)) { + trap("truncSFloat of nan"); + } + if (curr->type == Type::i32) { + if (value.type == Type::f32) { + if (!isInRangeI32TruncS(value.reinterpreti32())) { + trap("i32.truncSFloat overflow"); + } + } else { + if (!isInRangeI32TruncS(value.reinterpreti64())) { + trap("i32.truncSFloat overflow"); + } + } + return Literal(int32_t(val)); + } else { + if (value.type == Type::f32) { + if (!isInRangeI64TruncS(value.reinterpreti32())) { + trap("i64.truncSFloat overflow"); + } + } else { + if (!isInRangeI64TruncS(value.reinterpreti64())) { + trap("i64.truncSFloat overflow"); + } + } + return Literal(int64_t(val)); + } + } + + Literal truncUFloat(Unary* curr, Literal value) { + double val = value.getFloat(); + if (std::isnan(val)) { + trap("truncUFloat of nan"); + } + if (curr->type == Type::i32) { + if (value.type == Type::f32) { + if (!isInRangeI32TruncU(value.reinterpreti32())) { + trap("i32.truncUFloat overflow"); + } + } else { + if (!isInRangeI32TruncU(value.reinterpreti64())) { + trap("i32.truncUFloat overflow"); + } + } + return Literal(uint32_t(val)); + } else { + if (value.type == Type::f32) { + if (!isInRangeI64TruncU(value.reinterpreti32())) { + trap("i64.truncUFloat overflow"); + } + } else { + if (!isInRangeI64TruncU(value.reinterpreti64())) { + trap("i64.truncUFloat overflow"); + } + } + return Literal(uint64_t(val)); + } + } + Flow visitAtomicFence(AtomicFence* curr) { + // Wasm currently supports only sequentially consistent atomics, in which + // case atomic_fence can be lowered to nothing. + NOTE_ENTER("AtomicFence"); + return Flow(); + } + Flow visitTupleMake(TupleMake* curr) { + NOTE_ENTER("tuple.make"); + LiteralList arguments; + Flow flow = generateArguments(curr->operands, arguments); + if (flow.breaking()) { + return flow; + } + for (auto arg : arguments) { + assert(arg.type.isConcrete()); + flow.values.push_back(arg); + } + return flow; + } + Flow visitTupleExtract(TupleExtract* curr) { + NOTE_ENTER("tuple.extract"); + Flow flow = visit(curr->tuple); + if (flow.breaking()) { + return flow; + } + assert(flow.values.size() > curr->index); + return Flow(flow.values[curr->index]); + } + Flow visitLocalGet(LocalGet* curr) { WASM_UNREACHABLE("unimp"); } + Flow visitLocalSet(LocalSet* curr) { WASM_UNREACHABLE("unimp"); } + Flow visitGlobalGet(GlobalGet* curr) { WASM_UNREACHABLE("unimp"); } + Flow visitGlobalSet(GlobalSet* curr) { WASM_UNREACHABLE("unimp"); } + Flow visitCall(Call* curr) { WASM_UNREACHABLE("unimp"); } + Flow visitCallIndirect(CallIndirect* curr) { WASM_UNREACHABLE("unimp"); } + Flow visitLoad(Load* curr) { WASM_UNREACHABLE("unimp"); } + Flow visitStore(Store* curr) { WASM_UNREACHABLE("unimp"); } + Flow visitMemorySize(MemorySize* curr) { WASM_UNREACHABLE("unimp"); } + Flow visitMemoryGrow(MemoryGrow* curr) { WASM_UNREACHABLE("unimp"); } + Flow visitMemoryInit(MemoryInit* curr) { WASM_UNREACHABLE("unimp"); } + Flow visitDataDrop(DataDrop* curr) { WASM_UNREACHABLE("unimp"); } + Flow visitMemoryCopy(MemoryCopy* curr) { WASM_UNREACHABLE("unimp"); } + Flow visitMemoryFill(MemoryFill* curr) { WASM_UNREACHABLE("unimp"); } + Flow visitAtomicRMW(AtomicRMW* curr) { WASM_UNREACHABLE("unimp"); } + Flow visitAtomicCmpxchg(AtomicCmpxchg* curr) { WASM_UNREACHABLE("unimp"); } + Flow visitAtomicWait(AtomicWait* curr) { WASM_UNREACHABLE("unimp"); } + Flow visitAtomicNotify(AtomicNotify* curr) { WASM_UNREACHABLE("unimp"); } + Flow visitSIMDLoad(SIMDLoad* curr) { WASM_UNREACHABLE("unimp"); } + Flow visitSIMDLoadSplat(SIMDLoad* curr) { WASM_UNREACHABLE("unimp"); } + Flow visitSIMDLoadExtend(SIMDLoad* curr) { WASM_UNREACHABLE("unimp"); } + Flow visitSIMDLoadZero(SIMDLoad* curr) { WASM_UNREACHABLE("unimp"); } + Flow visitPop(Pop* curr) { WASM_UNREACHABLE("unimp"); } + Flow visitRefNull(RefNull* curr) { + NOTE_ENTER("RefNull"); + return Literal::makeNull(curr->type); + } + Flow visitRefIsNull(RefIsNull* curr) { + NOTE_ENTER("RefIsNull"); + Flow flow = visit(curr->value); + if (flow.breaking()) { + return flow; + } + const auto& value = flow.getSingleValue(); + NOTE_EVAL1(value); + return Literal(value.isNull()); + } + Flow visitRefFunc(RefFunc* curr) { + NOTE_ENTER("RefFunc"); + NOTE_NAME(curr->func); + return Literal::makeFunc(curr->func); + } + Flow visitRefEq(RefEq* curr) { + NOTE_ENTER("RefEq"); + Flow flow = visit(curr->left); + if (flow.breaking()) { + return flow; + } + auto left = flow.getSingleValue(); + flow = visit(curr->right); + if (flow.breaking()) { + return flow; + } + auto right = flow.getSingleValue(); + NOTE_EVAL2(left, right); + return Literal(int32_t(left == right)); + } + Flow visitTry(Try* curr) { WASM_UNREACHABLE("unimp"); } + Flow visitThrow(Throw* curr) { + NOTE_ENTER("Throw"); + LiteralList arguments; + Flow flow = generateArguments(curr->operands, arguments); + if (flow.breaking()) { + return flow; + } + NOTE_EVAL1(curr->event); + auto exn = std::make_unique(); + exn->event = curr->event; + for (auto item : arguments) { + exn->values.push_back(item); + } + throwException(Literal::makeExn(std::move(exn))); + WASM_UNREACHABLE("throw"); + } + Flow visitRethrow(Rethrow* curr) { + NOTE_ENTER("Rethrow"); + Flow flow = visit(curr->exnref); + if (flow.breaking()) { + return flow; + } + const auto& value = flow.getSingleValue(); + if (value.isNull()) { + trap("rethrow: argument is null"); + } + throwException(value); + WASM_UNREACHABLE("rethrow"); + } + Flow visitBrOnExn(BrOnExn* curr) { + NOTE_ENTER("BrOnExn"); + Flow flow = this->visit(curr->exnref); + if (flow.breaking()) { + return flow; + } + const auto& value = flow.getSingleValue(); + if (value.isNull()) { + trap("br_on_exn: argument is null"); + } + auto ex = value.getExceptionPackage(); + if (curr->event != ex.event) { // Not taken + return flow; + } + // Taken + flow.values = ex.values; + flow.breakTo = curr->name; + return flow; + } + Flow visitI31New(I31New* curr) { + NOTE_ENTER("I31New"); + Flow flow = visit(curr->value); + if (flow.breaking()) { + return flow; + } + const auto& value = flow.getSingleValue(); + NOTE_EVAL1(value); + return Literal::makeI31(value.geti32()); + } + Flow visitI31Get(I31Get* curr) { + NOTE_ENTER("I31Get"); + Flow flow = visit(curr->i31); + if (flow.breaking()) { + return flow; + } + const auto& value = flow.getSingleValue(); + NOTE_EVAL1(value); + return Literal(value.geti31(curr->signed_)); + } + Flow visitRefTest(RefTest* curr) { + NOTE_ENTER("RefTest"); + WASM_UNREACHABLE("TODO (gc): ref.test"); + } + Flow visitRefCast(RefCast* curr) { + NOTE_ENTER("RefCast"); + WASM_UNREACHABLE("TODO (gc): ref.cast"); + } + Flow visitBrOnCast(BrOnCast* curr) { + NOTE_ENTER("BrOnCast"); + WASM_UNREACHABLE("TODO (gc): br_on_cast"); + } + Flow visitRttCanon(RttCanon* curr) { + NOTE_ENTER("RttCanon"); + WASM_UNREACHABLE("TODO (gc): rtt.canon"); + } + Flow visitRttSub(RttSub* curr) { + NOTE_ENTER("RttSub"); + WASM_UNREACHABLE("TODO (gc): rtt.sub"); + } + Flow visitStructNew(StructNew* curr) { + NOTE_ENTER("StructNew"); + WASM_UNREACHABLE("TODO (gc): struct.new"); + } + Flow visitStructGet(StructGet* curr) { + NOTE_ENTER("StructGet"); + WASM_UNREACHABLE("TODO (gc): struct.get"); + } + Flow visitStructSet(StructSet* curr) { + NOTE_ENTER("StructSet"); + WASM_UNREACHABLE("TODO (gc): struct.set"); + } + Flow visitArrayNew(ArrayNew* curr) { + NOTE_ENTER("ArrayNew"); + WASM_UNREACHABLE("TODO (gc): array.new"); + } + Flow visitArrayGet(ArrayGet* curr) { + NOTE_ENTER("ArrayGet"); + WASM_UNREACHABLE("TODO (gc): array.get"); + } + Flow visitArraySet(ArraySet* curr) { + NOTE_ENTER("ArraySet"); + WASM_UNREACHABLE("TODO (gc): array.set"); + } + Flow visitArrayLen(ArrayLen* curr) { + NOTE_ENTER("ArrayLen"); + WASM_UNREACHABLE("TODO (gc): array.len"); + } + + virtual void trap(const char* why) { WASM_UNREACHABLE("unimp"); } + + virtual void throwException(Literal exn) { WASM_UNREACHABLE("unimp"); } +}; + +// Execute a suspected constant expression (precompute and C-API). +template +class ConstantExpressionRunner : public ExpressionRunner { +public: + enum FlagValues { + // By default, just evaluate the expression, i.e. all we want to know is + // whether it computes down to a concrete value, where it is not necessary + // to preserve side effects like those of a `local.tee`. + DEFAULT = 0, + // Be very careful to preserve any side effects. For example, if we are + // intending to replace the expression with a constant afterwards, even if + // we can technically evaluate down to a constant, we still cannot replace + // the expression if it also sets a local, which must be preserved in this + // scenario so subsequent code keeps functioning. + PRESERVE_SIDEEFFECTS = 1 << 0, + // Traverse through function calls, attempting to compute their concrete + // value. Must not be used in function-parallel scenarios, where the called + // function might be concurrently modified, leading to undefined behavior. + TRAVERSE_CALLS = 1 << 1 + }; + + // Flags indicating special requirements, for example whether we are just + // evaluating (default), also going to replace the expression afterwards or + // executing in a function-parallel scenario. See FlagValues. + typedef uint32_t Flags; + + // Indicates no limit of maxDepth or maxLoopIterations. + static const Index NO_LIMIT = 0; + +protected: + // Optional module context to search for globals and called functions. NULL if + // we are not interested in any context. + Module* module = nullptr; + + // Flags indicating special requirements. See FlagValues. + Flags flags = FlagValues::DEFAULT; + + // Map remembering concrete local values set in the context of this flow. + std::unordered_map localValues; + // Map remembering concrete global values set in the context of this flow. + std::unordered_map globalValues; + +public: + struct NonconstantException { + }; // TODO: use a flow with a special name, as this is likely very slow + + ConstantExpressionRunner(Module* module, + Flags flags, + Index maxDepth, + Index maxLoopIterations) + : ExpressionRunner(maxDepth, maxLoopIterations), module(module), + flags(flags) {} + + // Gets the module this runner is operating on. + Module* getModule() { return module; } + + // Sets a known local value to use. + void setLocalValue(Index index, Literals& values) { + assert(values.isConcrete()); + localValues[index] = values; + } + + // Sets a known global value to use. + void setGlobalValue(Name name, Literals& values) { + assert(values.isConcrete()); + globalValues[name] = values; + } + + Flow visitLocalGet(LocalGet* curr) { + NOTE_ENTER("LocalGet"); + NOTE_EVAL1(curr->index); + // Check if a constant value has been set in the context of this runner. + auto iter = localValues.find(curr->index); + if (iter != localValues.end()) { + return Flow(iter->second); + } + return Flow(NONCONSTANT_FLOW); + } + Flow visitLocalSet(LocalSet* curr) { + NOTE_ENTER("LocalSet"); + NOTE_EVAL1(curr->index); + if (!(flags & FlagValues::PRESERVE_SIDEEFFECTS)) { + // If we are evaluating and not replacing the expression, remember the + // constant value set, if any, and see if there is a value flowing through + // a tee. + auto setFlow = ExpressionRunner::visit(curr->value); + if (!setFlow.breaking()) { + setLocalValue(curr->index, setFlow.values); + if (curr->type.isConcrete()) { + assert(curr->isTee()); + return setFlow; + } + return Flow(); + } + } + return Flow(NONCONSTANT_FLOW); + } + Flow visitGlobalGet(GlobalGet* curr) { + NOTE_ENTER("GlobalGet"); + NOTE_NAME(curr->name); + if (module != nullptr) { + auto* global = module->getGlobal(curr->name); + // Check if the global has an immutable value anyway + if (!global->imported() && !global->mutable_) { + return ExpressionRunner::visit(global->init); + } + } + // Check if a constant value has been set in the context of this runner. + auto iter = globalValues.find(curr->name); + if (iter != globalValues.end()) { + return Flow(iter->second); + } + return Flow(NONCONSTANT_FLOW); + } + Flow visitGlobalSet(GlobalSet* curr) { + NOTE_ENTER("GlobalSet"); + NOTE_NAME(curr->name); + if (!(flags & FlagValues::PRESERVE_SIDEEFFECTS) && module != nullptr) { + // If we are evaluating and not replacing the expression, remember the + // constant value set, if any, for subsequent gets. + auto* global = module->getGlobal(curr->name); + assert(global->mutable_); + auto setFlow = ExpressionRunner::visit(curr->value); + if (!setFlow.breaking()) { + setGlobalValue(curr->name, setFlow.values); + return Flow(); + } + } + return Flow(NONCONSTANT_FLOW); + } + Flow visitCall(Call* curr) { + NOTE_ENTER("Call"); + NOTE_NAME(curr->target); + // Traverse into functions using the same mode, which we can also do + // when replacing as long as the function does not have any side effects. + // Might yield something useful for simple functions like `clamp`, sometimes + // even if arguments are only partially constant or not constant at all. + if ((flags & FlagValues::TRAVERSE_CALLS) != 0 && module != nullptr) { + auto* func = module->getFunction(curr->target); + if (!func->imported()) { + if (func->sig.results.isConcrete()) { + auto numOperands = curr->operands.size(); + assert(numOperands == func->getNumParams()); + auto prevLocalValues = localValues; + localValues.clear(); + for (Index i = 0; i < numOperands; ++i) { + auto argFlow = ExpressionRunner::visit(curr->operands[i]); + if (!argFlow.breaking()) { + assert(argFlow.values.isConcrete()); + localValues[i] = argFlow.values; + } + } + auto retFlow = ExpressionRunner::visit(func->body); + localValues = prevLocalValues; + if (retFlow.breakTo == RETURN_FLOW) { + return Flow(retFlow.values); + } else if (!retFlow.breaking()) { + return retFlow; + } + } + } + } + return Flow(NONCONSTANT_FLOW); + } + + Flow visitCallIndirect(CallIndirect* curr) { + NOTE_ENTER("CallIndirect"); + return Flow(NONCONSTANT_FLOW); + } + Flow visitLoad(Load* curr) { + NOTE_ENTER("Load"); + return Flow(NONCONSTANT_FLOW); + } + Flow visitStore(Store* curr) { + NOTE_ENTER("Store"); + return Flow(NONCONSTANT_FLOW); + } + Flow visitMemorySize(MemorySize* curr) { + NOTE_ENTER("MemorySize"); + return Flow(NONCONSTANT_FLOW); + } + Flow visitMemoryGrow(MemoryGrow* curr) { + NOTE_ENTER("MemoryGrow"); + return Flow(NONCONSTANT_FLOW); + } + Flow visitMemoryInit(MemoryInit* curr) { + NOTE_ENTER("MemoryInit"); + return Flow(NONCONSTANT_FLOW); + } + Flow visitDataDrop(DataDrop* curr) { + NOTE_ENTER("DataDrop"); + return Flow(NONCONSTANT_FLOW); + } + Flow visitMemoryCopy(MemoryCopy* curr) { + NOTE_ENTER("MemoryCopy"); + return Flow(NONCONSTANT_FLOW); + } + Flow visitMemoryFill(MemoryFill* curr) { + NOTE_ENTER("MemoryFill"); + return Flow(NONCONSTANT_FLOW); + } + Flow visitAtomicRMW(AtomicRMW* curr) { + NOTE_ENTER("AtomicRMW"); + return Flow(NONCONSTANT_FLOW); + } + Flow visitAtomicCmpxchg(AtomicCmpxchg* curr) { + NOTE_ENTER("AtomicCmpxchg"); + return Flow(NONCONSTANT_FLOW); + } + Flow visitAtomicWait(AtomicWait* curr) { + NOTE_ENTER("AtomicWait"); + return Flow(NONCONSTANT_FLOW); + } + Flow visitAtomicNotify(AtomicNotify* curr) { + NOTE_ENTER("AtomicNotify"); + return Flow(NONCONSTANT_FLOW); + } + Flow visitSIMDLoad(SIMDLoad* curr) { + NOTE_ENTER("SIMDLoad"); + return Flow(NONCONSTANT_FLOW); + } + Flow visitSIMDLoadSplat(SIMDLoad* curr) { + NOTE_ENTER("SIMDLoadSplat"); + return Flow(NONCONSTANT_FLOW); + } + Flow visitSIMDLoadExtend(SIMDLoad* curr) { + NOTE_ENTER("SIMDLoadExtend"); + return Flow(NONCONSTANT_FLOW); + } + Flow visitPop(Pop* curr) { + NOTE_ENTER("Pop"); + return Flow(NONCONSTANT_FLOW); + } + Flow visitTry(Try* curr) { + NOTE_ENTER("Try"); + return Flow(NONCONSTANT_FLOW); + } + + void trap(const char* why) override { throw NonconstantException(); } + + virtual void throwException(Literal exn) override { + throw NonconstantException(); + } +}; + +// Execute an initializer expression of a global, data or element segment. +// see: https://webassembly.org/docs/modules/#initializer-expression +template +class InitializerExpressionRunner + : public ExpressionRunner> { + GlobalManager& globals; + +public: + InitializerExpressionRunner(GlobalManager& globals, Index maxDepth) + : ExpressionRunner>(maxDepth), + globals(globals) {} + + Flow visitGlobalGet(GlobalGet* curr) { return Flow(globals[curr->name]); } +}; + +// +// An instance of a WebAssembly module, which can execute it via AST +// interpretation. +// +// To embed this interpreter, you need to provide an ExternalInterface instance +// (see below) which provides the embedding-specific details, that is, how to +// connect to the embedding implementation. +// +// To call into the interpreter, use callExport. +// + +template class ModuleInstanceBase { +public: + // + // You need to implement one of these to create a concrete interpreter. The + // ExternalInterface provides embedding-specific functionality like calling + // an imported function or accessing memory. + // + struct ExternalInterface { + virtual void init(Module& wasm, SubType& instance) {} + virtual void importGlobals(GlobalManager& globals, Module& wasm) = 0; + virtual Literals callImport(Function* import, LiteralList& arguments) = 0; + virtual Literals callTable(Index index, + Signature sig, + LiteralList& arguments, + Type result, + SubType& instance) = 0; + virtual bool growMemory(Address oldSize, Address newSize) = 0; + virtual void trap(const char* why) = 0; + virtual void throwException(Literal exnref) = 0; + + // the default impls for load and store switch on the sizes. you can either + // customize load/store, or the sub-functions which they call + virtual Literal load(Load* load, Address addr) { + switch (load->type.getBasic()) { + case Type::i32: { + switch (load->bytes) { + case 1: + return load->signed_ ? Literal((int32_t)load8s(addr)) + : Literal((int32_t)load8u(addr)); + case 2: + return load->signed_ ? Literal((int32_t)load16s(addr)) + : Literal((int32_t)load16u(addr)); + case 4: + return Literal((int32_t)load32s(addr)); + default: + WASM_UNREACHABLE("invalid size"); + } + break; + } + case Type::i64: { + switch (load->bytes) { + case 1: + return load->signed_ ? Literal((int64_t)load8s(addr)) + : Literal((int64_t)load8u(addr)); + case 2: + return load->signed_ ? Literal((int64_t)load16s(addr)) + : Literal((int64_t)load16u(addr)); + case 4: + return load->signed_ ? Literal((int64_t)load32s(addr)) + : Literal((int64_t)load32u(addr)); + case 8: + return Literal((int64_t)load64s(addr)); + default: + WASM_UNREACHABLE("invalid size"); + } + break; + } + case Type::f32: + return Literal(load32u(addr)).castToF32(); + case Type::f64: + return Literal(load64u(addr)).castToF64(); + case Type::v128: + return Literal(load128(addr).data()); + case Type::funcref: + case Type::externref: + case Type::exnref: + case Type::anyref: + case Type::eqref: + case Type::i31ref: + case Type::none: + case Type::unreachable: + WASM_UNREACHABLE("unexpected type"); + } + WASM_UNREACHABLE("invalid type"); + } + virtual void store(Store* store, Address addr, Literal value) { + switch (store->valueType.getBasic()) { + case Type::i32: { + switch (store->bytes) { + case 1: + store8(addr, value.geti32()); + break; + case 2: + store16(addr, value.geti32()); + break; + case 4: + store32(addr, value.geti32()); + break; + default: + WASM_UNREACHABLE("invalid store size"); + } + break; + } + case Type::i64: { + switch (store->bytes) { + case 1: + store8(addr, value.geti64()); + break; + case 2: + store16(addr, value.geti64()); + break; + case 4: + store32(addr, value.geti64()); + break; + case 8: + store64(addr, value.geti64()); + break; + default: + WASM_UNREACHABLE("invalid store size"); + } + break; + } + // write floats carefully, ensuring all bits reach memory + case Type::f32: + store32(addr, value.reinterpreti32()); + break; + case Type::f64: + store64(addr, value.reinterpreti64()); + break; + case Type::v128: + store128(addr, value.getv128()); + break; + case Type::funcref: + case Type::externref: + case Type::exnref: + case Type::anyref: + case Type::eqref: + case Type::i31ref: + case Type::none: + case Type::unreachable: + WASM_UNREACHABLE("unexpected type"); + } + } + + virtual int8_t load8s(Address addr) { WASM_UNREACHABLE("unimp"); } + virtual uint8_t load8u(Address addr) { WASM_UNREACHABLE("unimp"); } + virtual int16_t load16s(Address addr) { WASM_UNREACHABLE("unimp"); } + virtual uint16_t load16u(Address addr) { WASM_UNREACHABLE("unimp"); } + virtual int32_t load32s(Address addr) { WASM_UNREACHABLE("unimp"); } + virtual uint32_t load32u(Address addr) { WASM_UNREACHABLE("unimp"); } + virtual int64_t load64s(Address addr) { WASM_UNREACHABLE("unimp"); } + virtual uint64_t load64u(Address addr) { WASM_UNREACHABLE("unimp"); } + virtual std::array load128(Address addr) { + WASM_UNREACHABLE("unimp"); + } + + virtual void store8(Address addr, int8_t value) { + WASM_UNREACHABLE("unimp"); + } + virtual void store16(Address addr, int16_t value) { + WASM_UNREACHABLE("unimp"); + } + virtual void store32(Address addr, int32_t value) { + WASM_UNREACHABLE("unimp"); + } + virtual void store64(Address addr, int64_t value) { + WASM_UNREACHABLE("unimp"); + } + virtual void store128(Address addr, const std::array&) { + WASM_UNREACHABLE("unimp"); + } + + virtual void tableStore(Address addr, Name entry) { + WASM_UNREACHABLE("unimp"); + } + }; + + SubType* self() { return static_cast(this); } + + Module& wasm; + + // Values of globals + GlobalManager globals; + + // Multivalue ABI support (see push/pop). + std::vector multiValues; + + ModuleInstanceBase(Module& wasm, ExternalInterface* externalInterface) + : wasm(wasm), externalInterface(externalInterface) { + // import globals from the outside + externalInterface->importGlobals(globals, wasm); + // prepare memory + memorySize = wasm.memory.initial; + // generate internal (non-imported) globals + ModuleUtils::iterDefinedGlobals(wasm, [&](Global* global) { + globals[global->name] = + InitializerExpressionRunner(globals, maxDepth) + .visit(global->init) + .values; + }); + + // initialize the rest of the external interface + externalInterface->init(wasm, *self()); + + initializeTableContents(); + initializeMemoryContents(); + + // run start, if present + if (wasm.start.is()) { + LiteralList arguments; + callFunction(wasm.start, arguments); + } + } + + // call an exported function + Literals callExport(Name name, const LiteralList& arguments) { + Export* export_ = wasm.getExportOrNull(name); + if (!export_) { + externalInterface->trap("callExport not found"); + } + return callFunction(export_->value, arguments); + } + + Literals callExport(Name name) { return callExport(name, LiteralList()); } + + // get an exported global + Literals getExport(Name name) { + Export* export_ = wasm.getExportOrNull(name); + if (!export_) { + externalInterface->trap("getExport external not found"); + } + Name internalName = export_->value; + auto iter = globals.find(internalName); + if (iter == globals.end()) { + externalInterface->trap("getExport internal not found"); + } + return iter->second; + } + + std::string printFunctionStack() { + std::string ret = "/== (binaryen interpreter stack trace)\n"; + for (int i = int(functionStack.size()) - 1; i >= 0; i--) { + ret += std::string("|: ") + functionStack[i].str + "\n"; + } + ret += std::string("\\==\n"); + return ret; + } + +private: + // Keep a record of call depth, to guard against excessive recursion. + size_t callDepth; + + // Function name stack. We maintain this explicitly to allow printing of + // stack traces. + std::vector functionStack; + + std::unordered_set droppedSegments; + + void initializeTableContents() { + for (auto& segment : wasm.table.segments) { + Address offset = + (uint32_t)InitializerExpressionRunner(globals, maxDepth) + .visit(segment.offset) + .getSingleValue() + .geti32(); + if (offset + segment.data.size() > wasm.table.initial) { + externalInterface->trap("invalid offset when initializing table"); + } + for (size_t i = 0; i != segment.data.size(); ++i) { + externalInterface->tableStore(offset + i, segment.data[i]); + } + } + } + + void initializeMemoryContents() { + Const offset; + offset.value = Literal(uint32_t(0)); + offset.finalize(); + + // apply active memory segments + for (size_t i = 0, e = wasm.memory.segments.size(); i < e; ++i) { + Memory::Segment& segment = wasm.memory.segments[i]; + if (segment.isPassive) { + continue; + } + + Const size; + size.value = Literal(uint32_t(segment.data.size())); + size.finalize(); + + MemoryInit init; + init.segment = i; + init.dest = segment.offset; + init.offset = &offset; + init.size = &size; + init.finalize(); + + DataDrop drop; + drop.segment = i; + drop.finalize(); + + // we don't actually have a function, but we need one in order to visit + // the memory.init and data.drop instructions. + Function dummyFunc; + FunctionScope dummyScope(&dummyFunc, {}); + RuntimeExpressionRunner runner(*this, dummyScope, maxDepth); + runner.visit(&init); + runner.visit(&drop); + } + } + + class FunctionScope { + public: + std::vector locals; + Function* function; + + FunctionScope(Function* function, const LiteralList& arguments) + : function(function) { + if (function->sig.params.size() != arguments.size()) { + std::cerr << "Function `" << function->name << "` expects " + << function->sig.params.size() << " parameters, got " + << arguments.size() << " arguments." << std::endl; + WASM_UNREACHABLE("invalid param count"); + } + locals.resize(function->getNumLocals()); + for (size_t i = 0; i < function->getNumLocals(); i++) { + if (i < arguments.size()) { + if (!Type::isSubType(arguments[i].type, function->sig.params[i])) { + std::cerr << "Function `" << function->name << "` expects type " + << function->sig.params[i] << " for parameter " << i + << ", got " << arguments[i].type << "." << std::endl; + WASM_UNREACHABLE("invalid param count"); + } + locals[i] = {arguments[i]}; + } else { + assert(function->isVar(i)); + locals[i] = Literal::makeZeros(function->getLocalType(i)); + } + } + } + }; + + // Executes expressions with concrete runtime info, the function and module at + // runtime + class RuntimeExpressionRunner + : public ExpressionRunner { + ModuleInstanceBase& instance; + FunctionScope& scope; + + public: + RuntimeExpressionRunner(ModuleInstanceBase& instance, + FunctionScope& scope, + Index maxDepth) + : ExpressionRunner(maxDepth), instance(instance), + scope(scope) {} + + Flow visitCall(Call* curr) { + NOTE_ENTER("Call"); + NOTE_NAME(curr->target); + LiteralList arguments; + Flow flow = this->generateArguments(curr->operands, arguments); + if (flow.breaking()) { + return flow; + } + auto* func = instance.wasm.getFunction(curr->target); + Flow ret; + if (func->imported()) { + ret.values = instance.externalInterface->callImport(func, arguments); + } else { + ret.values = instance.callFunctionInternal(curr->target, arguments); + } +#ifdef WASM_INTERPRETER_DEBUG + std::cout << "(returned to " << scope.function->name << ")\n"; +#endif + // TODO: make this a proper tail call (return first) + if (curr->isReturn) { + ret.breakTo = RETURN_FLOW; + } + return ret; + } + Flow visitCallIndirect(CallIndirect* curr) { + NOTE_ENTER("CallIndirect"); + LiteralList arguments; + Flow flow = this->generateArguments(curr->operands, arguments); + if (flow.breaking()) { + return flow; + } + Flow target = this->visit(curr->target); + if (target.breaking()) { + return target; + } + Index index = target.getSingleValue().geti32(); + Type type = curr->isReturn ? scope.function->sig.results : curr->type; + Flow ret = instance.externalInterface->callTable( + index, curr->sig, arguments, type, *instance.self()); + // TODO: make this a proper tail call (return first) + if (curr->isReturn) { + ret.breakTo = RETURN_FLOW; + } + return ret; + } + + Flow visitLocalGet(LocalGet* curr) { + NOTE_ENTER("LocalGet"); + auto index = curr->index; + NOTE_EVAL1(index); + NOTE_EVAL1(scope.locals[index]); + return scope.locals[index]; + } + Flow visitLocalSet(LocalSet* curr) { + NOTE_ENTER("LocalSet"); + auto index = curr->index; + Flow flow = this->visit(curr->value); + if (flow.breaking()) { + return flow; + } + NOTE_EVAL1(index); + NOTE_EVAL1(flow.getSingleValue()); + assert(curr->isTee() ? Type::isSubType(flow.getType(), curr->type) + : true); + scope.locals[index] = flow.values; + return curr->isTee() ? flow : Flow(); + } + + Flow visitGlobalGet(GlobalGet* curr) { + NOTE_ENTER("GlobalGet"); + auto name = curr->name; + NOTE_EVAL1(name); + assert(instance.globals.find(name) != instance.globals.end()); + NOTE_EVAL1(instance.globals[name]); + return instance.globals[name]; + } + Flow visitGlobalSet(GlobalSet* curr) { + NOTE_ENTER("GlobalSet"); + auto name = curr->name; + Flow flow = this->visit(curr->value); + if (flow.breaking()) { + return flow; + } + NOTE_EVAL1(name); + NOTE_EVAL1(flow.getSingleValue()); + instance.globals[name] = flow.values; + return Flow(); + } + + Flow visitLoad(Load* curr) { + NOTE_ENTER("Load"); + Flow flow = this->visit(curr->ptr); + if (flow.breaking()) { + return flow; + } + NOTE_EVAL1(flow); + auto addr = instance.getFinalAddress(curr, flow.getSingleValue()); + if (curr->isAtomic) { + instance.checkAtomicAddress(addr, curr->bytes); + } + auto ret = instance.externalInterface->load(curr, addr); + NOTE_EVAL1(addr); + NOTE_EVAL1(ret); + return ret; + } + Flow visitStore(Store* curr) { + NOTE_ENTER("Store"); + Flow ptr = this->visit(curr->ptr); + if (ptr.breaking()) { + return ptr; + } + Flow value = this->visit(curr->value); + if (value.breaking()) { + return value; + } + auto addr = instance.getFinalAddress(curr, ptr.getSingleValue()); + if (curr->isAtomic) { + instance.checkAtomicAddress(addr, curr->bytes); + } + NOTE_EVAL1(addr); + NOTE_EVAL1(value); + instance.externalInterface->store(curr, addr, value.getSingleValue()); + return Flow(); + } + + Flow visitAtomicRMW(AtomicRMW* curr) { + NOTE_ENTER("AtomicRMW"); + Flow ptr = this->visit(curr->ptr); + if (ptr.breaking()) { + return ptr; + } + auto value = this->visit(curr->value); + if (value.breaking()) { + return value; + } + NOTE_EVAL1(ptr); + auto addr = instance.getFinalAddress(curr, ptr.getSingleValue()); + NOTE_EVAL1(addr); + NOTE_EVAL1(value); + auto loaded = instance.doAtomicLoad(addr, curr->bytes, curr->type); + NOTE_EVAL1(loaded); + auto computed = value.getSingleValue(); + switch (curr->op) { + case Add: + computed = loaded.add(computed); + break; + case Sub: + computed = loaded.sub(computed); + break; + case And: + computed = loaded.and_(computed); + break; + case Or: + computed = loaded.or_(computed); + break; + case Xor: + computed = loaded.xor_(computed); + break; + case Xchg: + break; + } + instance.doAtomicStore(addr, curr->bytes, computed); + return loaded; + } + Flow visitAtomicCmpxchg(AtomicCmpxchg* curr) { + NOTE_ENTER("AtomicCmpxchg"); + Flow ptr = this->visit(curr->ptr); + if (ptr.breaking()) { + return ptr; + } + NOTE_EVAL1(ptr); + auto expected = this->visit(curr->expected); + if (expected.breaking()) { + return expected; + } + auto replacement = this->visit(curr->replacement); + if (replacement.breaking()) { + return replacement; + } + auto addr = instance.getFinalAddress(curr, ptr.getSingleValue()); + expected = + Flow(wrapToSmallerSize(expected.getSingleValue(), curr->bytes)); + NOTE_EVAL1(addr); + NOTE_EVAL1(expected); + NOTE_EVAL1(replacement); + auto loaded = instance.doAtomicLoad(addr, curr->bytes, curr->type); + NOTE_EVAL1(loaded); + if (loaded == expected.getSingleValue()) { + instance.doAtomicStore(addr, curr->bytes, replacement.getSingleValue()); + } + return loaded; + } + Flow visitAtomicWait(AtomicWait* curr) { + NOTE_ENTER("AtomicWait"); + Flow ptr = this->visit(curr->ptr); + if (ptr.breaking()) { + return ptr; + } + NOTE_EVAL1(ptr); + auto expected = this->visit(curr->expected); + NOTE_EVAL1(expected); + if (expected.breaking()) { + return expected; + } + auto timeout = this->visit(curr->timeout); + NOTE_EVAL1(timeout); + if (timeout.breaking()) { + return timeout; + } + auto bytes = curr->expectedType.getByteSize(); + auto addr = instance.getFinalAddress(curr, ptr.getSingleValue(), bytes); + auto loaded = instance.doAtomicLoad(addr, bytes, curr->expectedType); + NOTE_EVAL1(loaded); + if (loaded != expected.getSingleValue()) { + return Literal(int32_t(1)); // not equal + } + // TODO: add threads support! + // for now, just assume we are woken up + return Literal(int32_t(0)); // woken up + } + Flow visitAtomicNotify(AtomicNotify* curr) { + NOTE_ENTER("AtomicNotify"); + Flow ptr = this->visit(curr->ptr); + if (ptr.breaking()) { + return ptr; + } + NOTE_EVAL1(ptr); + auto count = this->visit(curr->notifyCount); + NOTE_EVAL1(count); + if (count.breaking()) { + return count; + } + auto addr = instance.getFinalAddress(curr, ptr.getSingleValue(), 4); + // Just check TODO actual threads support + instance.checkAtomicAddress(addr, 4); + return Literal(int32_t(0)); // none woken up + } + Flow visitSIMDLoad(SIMDLoad* curr) { + NOTE_ENTER("SIMDLoad"); + switch (curr->op) { + case LoadSplatVec8x16: + case LoadSplatVec16x8: + case LoadSplatVec32x4: + case LoadSplatVec64x2: + return visitSIMDLoadSplat(curr); + case LoadExtSVec8x8ToVecI16x8: + case LoadExtUVec8x8ToVecI16x8: + case LoadExtSVec16x4ToVecI32x4: + case LoadExtUVec16x4ToVecI32x4: + case LoadExtSVec32x2ToVecI64x2: + case LoadExtUVec32x2ToVecI64x2: + return visitSIMDLoadExtend(curr); + case Load32Zero: + case Load64Zero: + return visitSIMDLoadZero(curr); + } + WASM_UNREACHABLE("invalid op"); + } + Flow visitSIMDLoadSplat(SIMDLoad* curr) { + Load load; + load.type = Type::i32; + load.bytes = curr->getMemBytes(); + load.signed_ = false; + load.offset = curr->offset; + load.align = curr->align; + load.isAtomic = false; + load.ptr = curr->ptr; + Literal (Literal::*splat)() const = nullptr; + switch (curr->op) { + case LoadSplatVec8x16: + splat = &Literal::splatI8x16; + break; + case LoadSplatVec16x8: + splat = &Literal::splatI16x8; + break; + case LoadSplatVec32x4: + splat = &Literal::splatI32x4; + break; + case LoadSplatVec64x2: + load.type = Type::i64; + splat = &Literal::splatI64x2; + break; + default: + WASM_UNREACHABLE("invalid op"); + } + load.finalize(); + Flow flow = this->visit(&load); + if (flow.breaking()) { + return flow; + } + return (flow.getSingleValue().*splat)(); + } + Flow visitSIMDLoadExtend(SIMDLoad* curr) { + Flow flow = this->visit(curr->ptr); + if (flow.breaking()) { + return flow; + } + NOTE_EVAL1(flow); + Address src(uint32_t(flow.getSingleValue().geti32())); + auto loadLane = [&](Address addr) { + switch (curr->op) { + case LoadExtSVec8x8ToVecI16x8: + return Literal(int32_t(instance.externalInterface->load8s(addr))); + case LoadExtUVec8x8ToVecI16x8: + return Literal(int32_t(instance.externalInterface->load8u(addr))); + case LoadExtSVec16x4ToVecI32x4: + return Literal(int32_t(instance.externalInterface->load16s(addr))); + case LoadExtUVec16x4ToVecI32x4: + return Literal(int32_t(instance.externalInterface->load16u(addr))); + case LoadExtSVec32x2ToVecI64x2: + return Literal(int64_t(instance.externalInterface->load32s(addr))); + case LoadExtUVec32x2ToVecI64x2: + return Literal(int64_t(instance.externalInterface->load32u(addr))); + default: + WASM_UNREACHABLE("unexpected op"); + } + WASM_UNREACHABLE("invalid op"); + }; + auto fillLanes = [&](auto lanes, size_t laneBytes) { + for (auto& lane : lanes) { + lane = loadLane( + instance.getFinalAddress(curr, Literal(uint32_t(src)), laneBytes)); + src = Address(uint32_t(src) + laneBytes); + } + return Literal(lanes); + }; + switch (curr->op) { + case LoadExtSVec8x8ToVecI16x8: + case LoadExtUVec8x8ToVecI16x8: { + std::array lanes; + return fillLanes(lanes, 1); + } + case LoadExtSVec16x4ToVecI32x4: + case LoadExtUVec16x4ToVecI32x4: { + std::array lanes; + return fillLanes(lanes, 2); + } + case LoadExtSVec32x2ToVecI64x2: + case LoadExtUVec32x2ToVecI64x2: { + std::array lanes; + return fillLanes(lanes, 4); + } + default: + WASM_UNREACHABLE("unexpected op"); + } + WASM_UNREACHABLE("invalid op"); + } + Flow visitSIMDLoadZero(SIMDLoad* curr) { + Flow flow = this->visit(curr->ptr); + if (flow.breaking()) { + return flow; + } + NOTE_EVAL1(flow); + Address src = instance.getFinalAddress( + curr, flow.getSingleValue(), curr->op == Load32Zero ? 32 : 64); + auto zero = + Literal::makeZero(curr->op == Load32Zero ? Type::i32 : Type::i64); + if (curr->op == Load32Zero) { + auto val = Literal(instance.externalInterface->load32u(src)); + return Literal(std::array{{val, zero, zero, zero}}); + } else { + auto val = Literal(instance.externalInterface->load64u(src)); + return Literal(std::array{{val, zero}}); + } + } + Flow visitMemorySize(MemorySize* curr) { + NOTE_ENTER("MemorySize"); + return Literal::makeFromInt64(instance.memorySize, + instance.wasm.memory.indexType); + } + Flow visitMemoryGrow(MemoryGrow* curr) { + NOTE_ENTER("MemoryGrow"); + auto indexType = instance.wasm.memory.indexType; + auto fail = Literal::makeFromInt64(-1, indexType); + Flow flow = this->visit(curr->delta); + if (flow.breaking()) { + return flow; + } + Flow ret = Literal::makeFromInt64(instance.memorySize, indexType); + uint64_t delta = flow.getSingleValue().getUnsigned(); + if (delta > uint32_t(-1) / Memory::kPageSize && indexType == Type::i32) { + return fail; + } + if (instance.memorySize >= uint32_t(-1) - delta && + indexType == Type::i32) { + return fail; + } + auto newSize = instance.memorySize + delta; + if (newSize > instance.wasm.memory.max) { + return fail; + } + if (!instance.externalInterface->growMemory( + instance.memorySize * Memory::kPageSize, + newSize * Memory::kPageSize)) { + // We failed to grow the memory in practice, even though it was valid + // to try to do so. + return fail; + } + instance.memorySize = newSize; + return ret; + } + Flow visitMemoryInit(MemoryInit* curr) { + NOTE_ENTER("MemoryInit"); + Flow dest = this->visit(curr->dest); + if (dest.breaking()) { + return dest; + } + Flow offset = this->visit(curr->offset); + if (offset.breaking()) { + return offset; + } + Flow size = this->visit(curr->size); + if (size.breaking()) { + return size; + } + NOTE_EVAL1(dest); + NOTE_EVAL1(offset); + NOTE_EVAL1(size); + + assert(curr->segment < instance.wasm.memory.segments.size()); + Memory::Segment& segment = instance.wasm.memory.segments[curr->segment]; + + Address destVal(dest.getSingleValue().getUnsigned()); + Address offsetVal(uint32_t(offset.getSingleValue().geti32())); + Address sizeVal(uint32_t(size.getSingleValue().geti32())); + + if (offsetVal + sizeVal > 0 && + instance.droppedSegments.count(curr->segment)) { + trap("out of bounds segment access in memory.init"); + } + if ((uint64_t)offsetVal + sizeVal > segment.data.size()) { + trap("out of bounds segment access in memory.init"); + } + if (destVal + sizeVal > instance.memorySize * Memory::kPageSize) { + trap("out of bounds memory access in memory.init"); + } + for (size_t i = 0; i < sizeVal; ++i) { + Literal addr(destVal + i); + instance.externalInterface->store8( + instance.getFinalAddressWithoutOffset(addr, 1), + segment.data[offsetVal + i]); + } + return {}; + } + Flow visitDataDrop(DataDrop* curr) { + NOTE_ENTER("DataDrop"); + instance.droppedSegments.insert(curr->segment); + return {}; + } + Flow visitMemoryCopy(MemoryCopy* curr) { + NOTE_ENTER("MemoryCopy"); + Flow dest = this->visit(curr->dest); + if (dest.breaking()) { + return dest; + } + Flow source = this->visit(curr->source); + if (source.breaking()) { + return source; + } + Flow size = this->visit(curr->size); + if (size.breaking()) { + return size; + } + NOTE_EVAL1(dest); + NOTE_EVAL1(source); + NOTE_EVAL1(size); + Address destVal(dest.getSingleValue().getUnsigned()); + Address sourceVal(source.getSingleValue().getUnsigned()); + Address sizeVal(size.getSingleValue().getUnsigned()); + + if (sourceVal + sizeVal > instance.memorySize * Memory::kPageSize || + destVal + sizeVal > instance.memorySize * Memory::kPageSize || + // FIXME: better/cheaper way to detect wrapping? + sourceVal + sizeVal < sourceVal || sourceVal + sizeVal < sizeVal || + destVal + sizeVal < destVal || destVal + sizeVal < sizeVal) { + trap("out of bounds segment access in memory.copy"); + } + + int64_t start = 0; + int64_t end = sizeVal; + int step = 1; + // Reverse direction if source is below dest + if (sourceVal < destVal) { + start = int64_t(sizeVal) - 1; + end = -1; + step = -1; + } + for (int64_t i = start; i != end; i += step) { + instance.externalInterface->store8( + instance.getFinalAddressWithoutOffset(Literal(destVal + i), 1), + instance.externalInterface->load8s( + instance.getFinalAddressWithoutOffset(Literal(sourceVal + i), 1))); + } + return {}; + } + Flow visitMemoryFill(MemoryFill* curr) { + NOTE_ENTER("MemoryFill"); + Flow dest = this->visit(curr->dest); + if (dest.breaking()) { + return dest; + } + Flow value = this->visit(curr->value); + if (value.breaking()) { + return value; + } + Flow size = this->visit(curr->size); + if (size.breaking()) { + return size; + } + NOTE_EVAL1(dest); + NOTE_EVAL1(value); + NOTE_EVAL1(size); + Address destVal(dest.getSingleValue().getUnsigned()); + Address sizeVal(size.getSingleValue().getUnsigned()); + + // FIXME: cheaper wrapping detection? + if (destVal > instance.memorySize * Memory::kPageSize || + sizeVal > instance.memorySize * Memory::kPageSize || + destVal + sizeVal > instance.memorySize * Memory::kPageSize) { + trap("out of bounds memory access in memory.fill"); + } + uint8_t val(value.getSingleValue().geti32()); + for (size_t i = 0; i < sizeVal; ++i) { + instance.externalInterface->store8( + instance.getFinalAddressWithoutOffset(Literal(destVal + i), 1), val); + } + return {}; + } + Flow visitTry(Try* curr) { + NOTE_ENTER("Try"); + try { + return this->visit(curr->body); + } catch (const WasmException& e) { + instance.multiValues.push_back(e.exn); + return this->visit(curr->catchBody); + } + } + Flow visitPop(Pop* curr) { + NOTE_ENTER("Pop"); + assert(!instance.multiValues.empty()); + auto ret = instance.multiValues.back(); + instance.multiValues.pop_back(); + return ret; + } + + void trap(const char* why) override { + instance.externalInterface->trap(why); + } + + void throwException(Literal exn) override { + instance.externalInterface->throwException(exn); + } + + // Given a value, wrap it to a smaller given number of bytes. + Literal wrapToSmallerSize(Literal value, Index bytes) { + if (value.type == Type::i32) { + switch (bytes) { + case 1: { + return value.and_(Literal(uint32_t(0xff))); + } + case 2: { + return value.and_(Literal(uint32_t(0xffff))); + } + case 4: { + break; + } + default: + WASM_UNREACHABLE("unexpected bytes"); + } + } else { + assert(value.type == Type::i64); + switch (bytes) { + case 1: { + return value.and_(Literal(uint64_t(0xff))); + } + case 2: { + return value.and_(Literal(uint64_t(0xffff))); + } + case 4: { + return value.and_(Literal(uint64_t(0xffffffffUL))); + } + case 8: { + break; + } + default: + WASM_UNREACHABLE("unexpected bytes"); + } + } + return value; + } + }; + +public: + // Call a function, starting an invocation. + Literals callFunction(Name name, const LiteralList& arguments) { + // if the last call ended in a jump up the stack, it might have left stuff + // for us to clean up here + callDepth = 0; + functionStack.clear(); + return callFunctionInternal(name, arguments); + } + + // Internal function call. Must be public so that callTable implementations + // can use it (refactor?) + Literals callFunctionInternal(Name name, const LiteralList& arguments) { + if (callDepth > maxDepth) { + externalInterface->trap("stack limit"); + } + auto previousCallDepth = callDepth; + callDepth++; + auto previousFunctionStackSize = functionStack.size(); + functionStack.push_back(name); + + Function* function = wasm.getFunction(name); + assert(function); + FunctionScope scope(function, arguments); + +#ifdef WASM_INTERPRETER_DEBUG + std::cout << "entering " << function->name << "\n with arguments:\n"; + for (unsigned i = 0; i < arguments.size(); ++i) { + std::cout << " $" << i << ": " << arguments[i] << '\n'; + } +#endif + + Flow flow = + RuntimeExpressionRunner(*this, scope, maxDepth).visit(function->body); + // cannot still be breaking, it means we missed our stop + assert(!flow.breaking() || flow.breakTo == RETURN_FLOW); + auto type = flow.getType(); + if (!Type::isSubType(type, function->sig.results)) { + std::cerr << "calling " << function->name << " resulted in " << type + << " but the function type is " << function->sig.results + << '\n'; + WASM_UNREACHABLE("unexpected result type"); + } + // may decrease more than one, if we jumped up the stack + callDepth = previousCallDepth; + // if we jumped up the stack, we also need to pop higher frames + while (functionStack.size() > previousFunctionStackSize) { + functionStack.pop_back(); + } +#ifdef WASM_INTERPRETER_DEBUG + std::cout << "exiting " << function->name << " with " << flow.values + << '\n'; +#endif + return flow.values; + } + +protected: + Address memorySize; // in pages + + static const Index maxDepth = 250; + + void trapIfGt(uint64_t lhs, uint64_t rhs, const char* msg) { + if (lhs > rhs) { + std::stringstream ss; + ss << msg << ": " << lhs << " > " << rhs; + externalInterface->trap(ss.str().c_str()); + } + } + + template + Address getFinalAddress(LS* curr, Literal ptr, Index bytes) { + Address memorySizeBytes = memorySize * Memory::kPageSize; + uint64_t addr = ptr.type == Type::i32 ? ptr.geti32() : ptr.geti64(); + trapIfGt(curr->offset, memorySizeBytes, "offset > memory"); + trapIfGt(addr, memorySizeBytes - curr->offset, "final > memory"); + addr += curr->offset; + trapIfGt(bytes, memorySizeBytes, "bytes > memory"); + checkLoadAddress(addr, bytes); + return addr; + } + + template Address getFinalAddress(LS* curr, Literal ptr) { + return getFinalAddress(curr, ptr, curr->bytes); + } + + Address getFinalAddressWithoutOffset(Literal ptr, Index bytes) { + uint64_t addr = ptr.type == Type::i32 ? ptr.geti32() : ptr.geti64(); + checkLoadAddress(addr, bytes); + return addr; + } + + void checkLoadAddress(Address addr, Index bytes) { + Address memorySizeBytes = memorySize * Memory::kPageSize; + trapIfGt(addr, memorySizeBytes - bytes, "highest > memory"); + } + + void checkAtomicAddress(Address addr, Index bytes) { + checkLoadAddress(addr, bytes); + // Unaligned atomics trap. + if (bytes > 1) { + if (addr & (bytes - 1)) { + externalInterface->trap("unaligned atomic operation"); + } + } + } + + Literal doAtomicLoad(Address addr, Index bytes, Type type) { + checkAtomicAddress(addr, bytes); + Const ptr; + ptr.value = Literal(int32_t(addr)); + ptr.type = Type::i32; + Load load; + load.bytes = bytes; + // When an atomic loads a partial number of bytes for the type, it is + // always an unsigned extension. + load.signed_ = false; + load.align = bytes; + load.isAtomic = true; // understatement + load.ptr = &ptr; + load.type = type; + return externalInterface->load(&load, addr); + } + + void doAtomicStore(Address addr, Index bytes, Literal toStore) { + checkAtomicAddress(addr, bytes); + Const ptr; + ptr.value = Literal(int32_t(addr)); + ptr.type = Type::i32; + Const value; + value.value = toStore; + value.type = toStore.type; + Store store; + store.bytes = bytes; + store.align = bytes; + store.isAtomic = true; // understatement + store.ptr = &ptr; + store.value = &value; + store.valueType = value.type; + return externalInterface->store(&store, addr, toStore); + } + + ExternalInterface* externalInterface; +}; + +// The default ModuleInstance uses a trivial global manager +using TrivialGlobalManager = std::map; +class ModuleInstance + : public ModuleInstanceBase { +public: + ModuleInstance(Module& wasm, ExternalInterface* externalInterface) + : ModuleInstanceBase(wasm, externalInterface) {} +}; + +} // namespace wasm + +#endif // wasm_wasm_interpreter_h diff --git a/binaryen/src/wasm-io.h b/binaryen/src/wasm-io.h new file mode 100644 --- /dev/null +++ b/binaryen/src/wasm-io.h @@ -0,0 +1,96 @@ +/* + * Copyright 2017 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// Abstracts reading and writing, supporting both text and binary. +// + +#ifndef wasm_wasm_io_h +#define wasm_wasm_io_h + +#include "parsing.h" +#include "support/file.h" +#include "wasm.h" + +namespace wasm { + +class ModuleReader { +public: + // If DWARF support is enabled, we track the locations of all IR nodes in + // the binary, so that we can update DWARF sections later when writing. + void setDWARF(bool DWARF_) { DWARF = DWARF_; } + + void setProfile(IRProfile profile_) { profile = profile_; } + + // read text + void readText(std::string filename, Module& wasm); + // read binary + void readBinary(std::string filename, + Module& wasm, + std::string sourceMapFilename = ""); + // read text or binary, checking the contents for what it is. If `filename` is + // empty, read from stdin. + void + read(std::string filename, Module& wasm, std::string sourceMapFilename = ""); + // check whether a file is a wasm binary + bool isBinaryFile(std::string filename); + +private: + bool DWARF = false; + + IRProfile profile = IRProfile::Normal; + + void readStdin(Module& wasm, std::string sourceMapFilename); + + void readBinaryData(std::vector& input, + Module& wasm, + std::string sourceMapFilename); +}; + +class ModuleWriter { + bool binary = true; + bool debugInfo = false; + std::string symbolMap; + std::string sourceMapFilename; + std::string sourceMapUrl; + +public: + void setBinary(bool binary_) { binary = binary_; } + void setDebugInfo(bool debugInfo_) { debugInfo = debugInfo_; } + void setSymbolMap(std::string symbolMap_) { symbolMap = symbolMap_; } + void setSourceMapFilename(std::string sourceMapFilename_) { + sourceMapFilename = sourceMapFilename_; + } + void setSourceMapUrl(std::string sourceMapUrl_) { + sourceMapUrl = sourceMapUrl_; + } + + // write text + void writeText(Module& wasm, Output& output); + void writeText(Module& wasm, std::string filename); + // write binary + void writeBinary(Module& wasm, Output& output); + void writeBinary(Module& wasm, std::string filename); + // write text or binary, defaulting to binary unless setBinary(false), + // and unless there is no output file (in which case we write text + // to stdout). + void write(Module& wasm, Output& output); + void write(Module& wasm, std::string filename); +}; + +} // namespace wasm + +#endif // wasm_wasm_io_h diff --git a/binaryen/src/wasm-module-building.h b/binaryen/src/wasm-module-building.h new file mode 100644 --- /dev/null +++ b/binaryen/src/wasm-module-building.h @@ -0,0 +1,324 @@ +/* + * Copyright 2016 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef wasm_wasm_module_building_h +#define wasm_wasm_module_building_h + +#include +#include + +namespace wasm { + +#ifdef BINARYEN_THREAD_DEBUG +static std::mutex debug; +#define DEBUG_THREAD(x) \ + { \ + std::lock_guard lock(debug); \ + std::cerr << "[OptimizingIncrementalModuleBuilder Threading (thread: " \ + << std::this_thread::get_id() << ")] " << x; \ + std::cerr << '\n'; \ + } +#else +#define DEBUG_THREAD(x) +#endif + +// +// OptimizingIncrementalModuleBuilder +// +// Helps build wasm modules efficiently. If you build a module by +// adding function by function, and you want to optimize them, this class +// starts optimizing using worker threads *while you are still adding*. +// It runs function optimization passes at that time. This does not +// run global optimization after that by default, but you can do that +// to by calling optimizeGlobally(), which runs the the global post-passes +// (we can't run the pre-passes, as they must be run before function +// passes, and no such time is possible here given that we receive +// functions one by one and optimize them). +// +// This might also be faster than normal module optimization since it +// runs all passes on each function, then goes on to the next function +// which is better for data locality. +// +// Usage: Create an instance, passing it the module and the total +// number of functions. Then call addFunction as you have +// new functions to add (this also adds it to the module). Finally, +// call finish() when all functions have been added. +// +// This avoids locking by using atomics. We allocate an array of nullptrs +// that represent all the functions, and as we add a function, we place it +// at the next index. Each worker will read from the start to the end, +// and when a non-nullptr is found, the worker optimizes that function and +// nulls it. There is also an end marker that is not nullptr nor the address of +// a valid function, which represents that beyond this point we have not +// yet filled in. In other words, +// * the main thread fills everything with the end marker +// * the main thread transforms a marker entry into a function +// * workers pause when they see the marker +// * workers skip over nullptrs +// * workers transform functions into nullptrs, and optimize them +// * we keep an atomic count of the number of active workers and +// the number of optimized functions. +// * after adding a function, the main thread notifys up workers if +// it calculates there is work for them. +// * a lock is used for going to sleep and waking up. +// Locking should be rare, as optimization is +// generally slower than generation; in the optimal case, we never +// lock beyond the first step, and all further work is lock-free. +// +// N.B.: Optimizing functions in parallel with adding functions is possible, +// but the rest of the global state of the module should be fixed, +// such as globals, imports, etc. Function-parallel optimization passes +// may read (but not modify) those fields. + +class OptimizingIncrementalModuleBuilder { + Module* wasm; + uint32_t numFunctions; + PassOptions passOptions; + std::function addPrePasses; + Function* endMarker; + std::atomic* list; + uint32_t nextFunction; // only used on main thread + uint32_t numWorkers; + std::vector> threads; + std::atomic liveWorkers, activeWorkers, availableFuncs, + finishedFuncs; + std::mutex mutex; + std::condition_variable condition; + bool finishing; + bool debug; + bool validateGlobally; + +public: + // numFunctions must be equal to the number of functions allocated, or higher. + // Knowing this bounds helps avoid locking. + OptimizingIncrementalModuleBuilder( + Module* wasm, + Index numFunctions, + PassOptions passOptions, + std::function addPrePasses, + bool debug, + bool validateGlobally) + : wasm(wasm), numFunctions(numFunctions), passOptions(passOptions), + addPrePasses(addPrePasses), endMarker(nullptr), list(nullptr), + nextFunction(0), numWorkers(0), liveWorkers(0), activeWorkers(0), + availableFuncs(0), finishedFuncs(0), finishing(false), debug(debug), + validateGlobally(validateGlobally) { + + if (!useWorkers()) { + // if we shouldn't use threads, don't + return; + } + + // Before parallelism, create all passes on the main thread here, to ensure + // prepareToRun() is called for each pass before we start to optimize + // functions. + { + PassRunner passRunner(wasm, passOptions); + addPrePasses(passRunner); + passRunner.addDefaultFunctionOptimizationPasses(); + } + + // prepare work list + endMarker = new Function(); + list = new std::atomic[numFunctions]; + for (uint32_t i = 0; i < numFunctions; i++) { + list[i].store(endMarker); + } + // create workers + DEBUG_THREAD("creating workers"); + numWorkers = ThreadPool::getNumCores(); + assert(numWorkers >= 1); + // worth it to use threads + liveWorkers.store(0); + activeWorkers.store(0); + // TODO: one less, and add it at the very end, to not compete with main + // thread? + for (uint32_t i = 0; i < numWorkers; i++) { + createWorker(); + } + waitUntilAllReady(); + DEBUG_THREAD("workers are ready"); + // prepare the rest of the initial state + availableFuncs.store(0); + finishedFuncs.store(0); + } + + ~OptimizingIncrementalModuleBuilder() { + delete[] list; + delete endMarker; + } + + bool useWorkers() { + return numFunctions > 0 && !debug && ThreadPool::getNumCores() > 1 && + !PassRunner::getPassDebug(); + } + + // Add a function to the module, and to be optimized + void addFunction(Function* func) { + wasm->addFunction(func); + if (!useWorkers()) { + return; // we optimize at the end in that case + } + queueFunction(func); + // notify workers if needed + auto notify = availableFuncs.load(); + for (uint32_t i = 0; i < notify; i++) { + notifyWorker(); + } + } + + // All functions have been added, block until all are optimized, and then do + // global optimizations. When this returns, the module is ready and optimized. + void finish() { + if (!useWorkers()) { + // optimize each function now that we are done adding functions, + // then optimize globally + PassRunner passRunner(wasm, passOptions); + if (debug) { + passRunner.setDebug(true); + passRunner.setValidateGlobally(validateGlobally); + } + addPrePasses(passRunner); + passRunner.addDefaultFunctionOptimizationPasses(); + passRunner.run(); + } else { + DEBUG_THREAD("finish()ing"); + assert(nextFunction == numFunctions); + notifyAllWorkers(); + waitUntilAllFinished(); + } + // TODO: clear side thread allocators from module allocator, as these + // threads were transient + } + +private: + void createWorker() { + DEBUG_THREAD("create a worker"); + threads.emplace_back(make_unique(workerMain, this)); + } + + void notifyWorker() { + DEBUG_THREAD("notify a worker"); + std::lock_guard lock(mutex); + condition.notify_one(); + } + + void notifyAllWorkers() { + DEBUG_THREAD("notify all workers"); + std::lock_guard lock(mutex); + condition.notify_all(); + } + + void waitUntilAllReady() { + DEBUG_THREAD("wait until all workers are ready"); + std::unique_lock lock(mutex); + if (liveWorkers.load() < numWorkers) { + condition.wait(lock, + [this]() { return liveWorkers.load() == numWorkers; }); + } + } + + void waitUntilAllFinished() { + DEBUG_THREAD("wait until all workers are finished"); + { + std::unique_lock lock(mutex); + finishing = true; + if (liveWorkers.load() > 0) { + condition.wait(lock, [this]() { return liveWorkers.load() == 0; }); + } + } + DEBUG_THREAD("joining"); + for (auto& thread : threads) { + thread->join(); + } + DEBUG_THREAD("joined"); + } + + void queueFunction(Function* func) { + DEBUG_THREAD("queue function"); + // TODO: if we are given more than we expected, use a slower work queue? + assert(nextFunction < numFunctions); + list[nextFunction++].store(func); + availableFuncs++; + } + + void optimizeGlobally() { + PassRunner passRunner(wasm, passOptions); + passRunner.addDefaultGlobalOptimizationPostPasses(); + passRunner.run(); + } + + // worker code + + void optimizeFunction(Function* func) { + PassRunner passRunner(wasm, passOptions); + addPrePasses(passRunner); + passRunner.addDefaultFunctionOptimizationPasses(); + passRunner.runOnFunction(func); + } + + static void workerMain(OptimizingIncrementalModuleBuilder* self) { + DEBUG_THREAD("workerMain"); + { + std::lock_guard lock(self->mutex); + self->liveWorkers++; + self->activeWorkers++; + self->condition.notify_all(); + } + for (uint32_t i = 0; i < self->numFunctions; i++) { + DEBUG_THREAD("workerMain iteration " << i); + if (self->list[i].load() == self->endMarker) { + // sleep, this entry isn't ready yet + DEBUG_THREAD("workerMain sleep"); + self->activeWorkers--; + { + std::unique_lock lock(self->mutex); + // while waiting for the lock, things may have ended + if (!self->finishing) { + self->condition.wait(lock); + } + } + // continue + DEBUG_THREAD("workerMain continue"); + self->activeWorkers++; + i--; + continue; + } + DEBUG_THREAD("workerMain exchange item"); + auto* func = self->list[i].exchange(nullptr); + if (func == nullptr) { + DEBUG_THREAD("workerMain sees was already taken"); + continue; // someone else has taken this one + } + // we have work to do! + DEBUG_THREAD("workerMain work on " << size_t(func)); + self->availableFuncs--; + self->optimizeFunction(func); + self->finishedFuncs++; + } + DEBUG_THREAD("workerMain ready to exit"); + { + std::lock_guard lock(self->mutex); + self->liveWorkers--; + self->condition.notify_all(); + } + DEBUG_THREAD("workerMain exiting"); + } +}; + +} // namespace wasm + +#endif // wasm_wasm_module_building_h diff --git a/binaryen/src/wasm-printing.h b/binaryen/src/wasm-printing.h new file mode 100644 --- /dev/null +++ b/binaryen/src/wasm-printing.h @@ -0,0 +1,70 @@ +/* + * Copyright 2016 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef wasm_wasm_printing_h +#define wasm_wasm_printing_h + +#include + +#include "pass.h" +#include "wasm.h" + +namespace wasm { + +struct WasmPrinter { + static std::ostream& printModule(Module* module, std::ostream& o); + + static std::ostream& printModule(Module* module); + + static std::ostream& printExpression(Expression* expression, + std::ostream& o, + bool minify = false, + bool full = false); + + static std::ostream& + printStackInst(StackInst* inst, std::ostream& o, Function* func = nullptr); + + static std::ostream& + printStackIR(StackIR* ir, std::ostream& o, Function* func = nullptr); +}; + +} // namespace wasm + +namespace std { + +inline std::ostream& operator<<(std::ostream& o, wasm::Module& module) { + return wasm::WasmPrinter::printModule(&module, o); +} + +inline std::ostream& operator<<(std::ostream& o, wasm::Expression& expression) { + return wasm::WasmPrinter::printExpression(&expression, o); +} + +inline std::ostream& operator<<(std::ostream& o, wasm::Expression* expression) { + return wasm::WasmPrinter::printExpression(expression, o); +} + +inline std::ostream& operator<<(std::ostream& o, wasm::StackInst& inst) { + return wasm::WasmPrinter::printStackInst(&inst, o); +} + +inline std::ostream& operator<<(std::ostream& o, wasm::StackIR& ir) { + return wasm::WasmPrinter::printStackIR(&ir, o); +} + +} // namespace std + +#endif // wasm_wasm_printing_h diff --git a/binaryen/src/wasm-s-parser.h b/binaryen/src/wasm-s-parser.h new file mode 100644 --- /dev/null +++ b/binaryen/src/wasm-s-parser.h @@ -0,0 +1,296 @@ +/* + * Copyright 2015 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// Parses WebAssembly code in S-Expression format, as in .wast files +// such as are in the spec test suite. +// + +#ifndef wasm_wasm_s_parser_h +#define wasm_wasm_s_parser_h + +#include "mixed_arena.h" +#include "parsing.h" // for UniqueNameMapper. TODO: move dependency to cpp file? +#include "wasm-builder.h" +#include "wasm.h" + +namespace wasm { + +class SourceLocation { +public: + cashew::IString filename; + uint32_t line; + uint32_t column; + SourceLocation(cashew::IString filename_, + uint32_t line_, + uint32_t column_ = 0) + : filename(filename_), line(line_), column(column_) {} +}; + +// +// An element in an S-Expression: a list or a string +// +class Element { + typedef ArenaVector List; + + bool isList_ = true; + List list_; + cashew::IString str_; + bool dollared_; + bool quoted_; + +public: + Element(MixedArena& allocator) : list_(allocator) {} + + bool isList() const { return isList_; } + bool isStr() const { return !isList_; } + bool dollared() const { return isStr() && dollared_; } + bool quoted() const { return isStr() && quoted_; } + + size_t line = -1; + size_t col = -1; + // original locations at the start/end of the S-Expression list + SourceLocation* startLoc = nullptr; + SourceLocation* endLoc = nullptr; + + // list methods + List& list(); + Element* operator[](unsigned i); + size_t size() { return list().size(); } + + // string methods + cashew::IString str() const; + const char* c_str() const; + Element* setString(cashew::IString str__, bool dollared__, bool quoted__); + Element* setMetadata(size_t line_, size_t col_, SourceLocation* startLoc_); + + // printing + friend std::ostream& operator<<(std::ostream& o, Element& e); + void dump(); +}; + +// +// Generic S-Expression parsing into lists +// +class SExpressionParser { + char* input; + size_t line; + char* lineStart; + SourceLocation* loc = nullptr; + + MixedArena allocator; + +public: + // Assumes control of and modifies the input. + SExpressionParser(char* input); + Element* root; + +private: + Element* parse(); + void skipWhitespace(); + void parseDebugLocation(); + Element* parseString(); +}; + +// +// SExpressions => WebAssembly module +// +class SExpressionWasmBuilder { + Module& wasm; + MixedArena& allocator; + IRProfile profile; + std::vector signatures; + std::unordered_map signatureIndices; + std::vector functionNames; + std::vector globalNames; + std::vector eventNames; + int functionCounter = 0; + int globalCounter = 0; + int eventCounter = 0; + // we need to know function return types before we parse their contents + std::map functionTypes; + std::unordered_map debugInfoFileIndices; + +public: + // Assumes control of and modifies the input. + SExpressionWasmBuilder(Module& wasm, Element& module, IRProfile profile); + +private: + // pre-parse types and function definitions, so we know function return types + // before parsing their contents + void preParseFunctionType(Element& s); + bool isImport(Element& curr); + void preParseImports(Element& curr); + void parseModuleElement(Element& curr); + + // function parsing state + std::unique_ptr currFunction; + bool brokeToAutoBlock; + + UniqueNameMapper nameMapper; + + Signature getFunctionSignature(Element& s); + Name getFunctionName(Element& s); + Name getGlobalName(Element& s); + Name getEventName(Element& s); + void parseStart(Element& s) { wasm.addStart(getFunctionName(*s[1])); } + + // returns the next index in s + size_t parseFunctionNames(Element& s, Name& name, Name& exportName); + void parseFunction(Element& s, bool preParseImport = false); + + Type stringToType(cashew::IString str, + bool allowError = false, + bool prefix = false) { + return stringToType(str.str, allowError, prefix); + } + Type + stringToType(const char* str, bool allowError = false, bool prefix = false); + HeapType stringToHeapType(cashew::IString str, bool prefix = false) { + return stringToHeapType(str.str, prefix); + } + HeapType stringToHeapType(const char* str, bool prefix = false); + Type elementToType(Element& s); + Type stringToLaneType(const char* str); + bool isType(cashew::IString str) { + return stringToType(str, true) != Type::none; + } + +public: + Expression* parseExpression(Element* s) { return parseExpression(*s); } + Expression* parseExpression(Element& s); + + Module& getModule() { return wasm; } + +private: + Expression* makeExpression(Element& s); + Expression* makeUnreachable(); + Expression* makeNop(); + Expression* makeBinary(Element& s, BinaryOp op); + Expression* makeUnary(Element& s, UnaryOp op); + Expression* makeSelect(Element& s); + Expression* makeDrop(Element& s); + Expression* makeMemorySize(Element& s); + Expression* makeMemoryGrow(Element& s); + Index getLocalIndex(Element& s); + Expression* makeLocalGet(Element& s); + Expression* makeLocalTee(Element& s); + Expression* makeLocalSet(Element& s); + Expression* makeGlobalGet(Element& s); + Expression* makeGlobalSet(Element& s); + Expression* makeBlock(Element& s); + Expression* makeThenOrElse(Element& s); + Expression* makeConst(Element& s, Type type); + Expression* makeLoad(Element& s, Type type, bool isAtomic); + Expression* makeStore(Element& s, Type type, bool isAtomic); + Expression* makeAtomicRMWOrCmpxchg(Element& s, Type type); + Expression* + makeAtomicRMW(Element& s, Type type, uint8_t bytes, const char* extra); + Expression* + makeAtomicCmpxchg(Element& s, Type type, uint8_t bytes, const char* extra); + Expression* makeAtomicWait(Element& s, Type type); + Expression* makeAtomicNotify(Element& s); + Expression* makeAtomicFence(Element& s); + Expression* makeSIMDExtract(Element& s, SIMDExtractOp op, size_t lanes); + Expression* makeSIMDReplace(Element& s, SIMDReplaceOp op, size_t lanes); + Expression* makeSIMDShuffle(Element& s); + Expression* makeSIMDTernary(Element& s, SIMDTernaryOp op); + Expression* makeSIMDShift(Element& s, SIMDShiftOp op); + Expression* makeSIMDLoad(Element& s, SIMDLoadOp op); + Expression* makeMemoryInit(Element& s); + Expression* makeDataDrop(Element& s); + Expression* makeMemoryCopy(Element& s); + Expression* makeMemoryFill(Element& s); + Expression* makePush(Element& s); + Expression* makePop(Element& s); + Expression* makeIf(Element& s); + Expression* makeMaybeBlock(Element& s, size_t i, Type type); + Expression* makeLoop(Element& s); + Expression* makeCall(Element& s, bool isReturn); + Expression* makeCallIndirect(Element& s, bool isReturn); + template + void parseCallOperands(Element& s, Index i, Index j, T* call) { + while (i < j) { + call->operands.push_back(parseExpression(s[i])); + i++; + } + } + Name getLabel(Element& s); + Expression* makeBreak(Element& s); + Expression* makeBreakTable(Element& s); + Expression* makeReturn(Element& s); + Expression* makeRefNull(Element& s); + Expression* makeRefIsNull(Element& s); + Expression* makeRefFunc(Element& s); + Expression* makeRefEq(Element& s); + Expression* makeTry(Element& s); + Expression* makeTryOrCatchBody(Element& s, Type type, bool isTry); + Expression* makeThrow(Element& s); + Expression* makeRethrow(Element& s); + Expression* makeBrOnExn(Element& s); + Expression* makeTupleMake(Element& s); + Expression* makeTupleExtract(Element& s); + Expression* makeI31New(Element& s); + Expression* makeI31Get(Element& s, bool signed_); + Expression* makeRefTest(Element& s); + Expression* makeRefCast(Element& s); + Expression* makeBrOnCast(Element& s); + Expression* makeRttCanon(Element& s); + Expression* makeRttSub(Element& s); + Expression* makeStructNew(Element& s, bool default_); + Expression* makeStructGet(Element& s); + Expression* makeStructGet(Element& s, bool signed_); + Expression* makeStructSet(Element& s); + Expression* makeArrayNew(Element& s, bool default_); + Expression* makeArrayGet(Element& s); + Expression* makeArrayGet(Element& s, bool signed_); + Expression* makeArraySet(Element& s); + Expression* makeArrayLen(Element& s); + + // Helper functions + Type parseOptionalResultType(Element& s, Index& i); + Index parseMemoryLimits(Element& s, Index i); + Index parseMemoryIndex(Element& s, Index i); + std::vector parseParamOrLocal(Element& s); + std::vector parseParamOrLocal(Element& s, size_t& localIndex); + std::vector parseResults(Element& s); + Signature parseTypeRef(Element& s); + size_t parseTypeUse(Element& s, + size_t startPos, + Signature& functionSignature, + std::vector& namedParams); + size_t + parseTypeUse(Element& s, size_t startPos, Signature& functionSignature); + + void stringToBinary(const char* input, size_t size, std::vector& data); + void parseMemory(Element& s, bool preParseImport = false); + void parseData(Element& s); + void parseInnerData(Element& s, Index i, Expression* offset, bool isPassive); + void parseExport(Element& s); + void parseImport(Element& s); + void parseGlobal(Element& s, bool preParseImport = false); + void parseTable(Element& s, bool preParseImport = false); + void parseElem(Element& s); + void parseInnerElem(Element& s, Index i = 1, Expression* offset = nullptr); + void parseType(Element& s); + void parseEvent(Element& s, bool preParseImport = false); + + Function::DebugLocation getDebugLocation(const SourceLocation& loc); +}; + +} // namespace wasm + +#endif // wasm_wasm_s_parser_h diff --git a/binaryen/src/wasm-stack.h b/binaryen/src/wasm-stack.h new file mode 100644 --- /dev/null +++ b/binaryen/src/wasm-stack.h @@ -0,0 +1,495 @@ +/* + * Copyright 2018 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef wasm_stack_h +#define wasm_stack_h + +#include "ir/branch-utils.h" +#include "ir/properties.h" +#include "pass.h" +#include "wasm-binary.h" +#include "wasm-traversal.h" +#include "wasm.h" + +namespace wasm { + +// Stack IR: an IR that represents code at the wasm binary format level, +// that is, a stack machine. Binaryen IR is *almost* identical to this, +// but as documented in README.md, there are a few differences, intended +// to make Binaryen IR fast and flexible for maximal optimization. Stack +// IR, on the other hand, is designed to optimize a few final things that +// can only really be done when modeling the stack machine format precisely. + +// Currently the benefits of Stack IR are minor, less than 1% reduction in +// code size. For that reason it is just a secondary IR, run optionally +// after the main IR has been optimized. However, if we improve Stack IR +// optimizations to a point where they have a significant impact, it's +// possible that could motivate investigating replacing the main IR with Stack +// IR (so that we have just a single IR). + +// A StackIR instance (see wasm.h) contains a linear sequence of +// stack instructions. This representation is very simple: just a single vector +// of all instructions, in order. +// * nullptr is allowed in the vector, representing something to skip. +// This is useful as a common thing optimizations do is remove instructions, +// so this way we can do so without compacting the vector all the time. + +// Direct writing binaryen IR to binary is fast. Otherwise, StackIRGenerator +// lets you optimize the Stack IR before emitting stack IR to binary (but the +// cost is that the extra IR in the middle makes things 20% slower than emitting +// binaryen IR to binary directly). + +// A Stack IR instruction. Most just directly reflect a Binaryen IR node, +// but we need extra ones for certain things. +class StackInst { +public: + StackInst(MixedArena&) {} + + enum Op { + Basic, // an instruction directly corresponding to a non-control-flow + // Binaryen IR node + BlockBegin, // the beginning of a block + BlockEnd, // the ending of a block + IfBegin, // the beginning of a if + IfElse, // the else of a if + IfEnd, // the ending of a if + LoopBegin, // the beginning of a loop + LoopEnd, // the ending of a loop + TryBegin, // the beginning of a try + Catch, // the catch within a try + TryEnd // the ending of a try + } op; + + Expression* origin; // the expression this originates from + + // the type - usually identical to the origin type, but e.g. wasm has no + // unreachable blocks, they must be none + Type type; +}; + +class BinaryInstWriter : public OverriddenVisitor { +public: + BinaryInstWriter(WasmBinaryWriter& parent, + BufferWithRandomAccess& o, + Function* func, + bool sourceMap, + bool DWARF) + : parent(parent), o(o), func(func), sourceMap(sourceMap), DWARF(DWARF) {} + + void visit(Expression* curr) { + if (func && !sourceMap) { + parent.writeDebugLocation(curr, func); + } + OverriddenVisitor::visit(curr); + if (func && !sourceMap) { + parent.writeDebugLocationEnd(curr, func); + } + } + + void visitBlock(Block* curr); + void visitIf(If* curr); + void visitLoop(Loop* curr); + void visitBreak(Break* curr); + void visitSwitch(Switch* curr); + void visitCall(Call* curr); + void visitCallIndirect(CallIndirect* curr); + void visitLocalGet(LocalGet* curr); + void visitLocalSet(LocalSet* curr); + void visitGlobalGet(GlobalGet* curr); + void visitGlobalSet(GlobalSet* curr); + void visitLoad(Load* curr); + void visitStore(Store* curr); + void visitAtomicRMW(AtomicRMW* curr); + void visitAtomicCmpxchg(AtomicCmpxchg* curr); + void visitAtomicWait(AtomicWait* curr); + void visitAtomicNotify(AtomicNotify* curr); + void visitAtomicFence(AtomicFence* curr); + void visitSIMDExtract(SIMDExtract* curr); + void visitSIMDReplace(SIMDReplace* curr); + void visitSIMDShuffle(SIMDShuffle* curr); + void visitSIMDTernary(SIMDTernary* curr); + void visitSIMDShift(SIMDShift* curr); + void visitSIMDLoad(SIMDLoad* curr); + void visitMemoryInit(MemoryInit* curr); + void visitDataDrop(DataDrop* curr); + void visitMemoryCopy(MemoryCopy* curr); + void visitMemoryFill(MemoryFill* curr); + void visitConst(Const* curr); + void visitUnary(Unary* curr); + void visitBinary(Binary* curr); + void visitSelect(Select* curr); + void visitReturn(Return* curr); + void visitMemorySize(MemorySize* curr); + void visitMemoryGrow(MemoryGrow* curr); + void visitRefNull(RefNull* curr); + void visitRefIsNull(RefIsNull* curr); + void visitRefFunc(RefFunc* curr); + void visitRefEq(RefEq* curr); + void visitTry(Try* curr); + void visitThrow(Throw* curr); + void visitRethrow(Rethrow* curr); + void visitBrOnExn(BrOnExn* curr); + void visitNop(Nop* curr); + void visitUnreachable(Unreachable* curr); + void visitDrop(Drop* curr); + void visitPop(Pop* curr); + void visitTupleMake(TupleMake* curr); + void visitTupleExtract(TupleExtract* curr); + void visitI31New(I31New* curr); + void visitI31Get(I31Get* curr); + void visitRefTest(RefTest* curr); + void visitRefCast(RefCast* curr); + void visitBrOnCast(BrOnCast* curr); + void visitRttCanon(RttCanon* curr); + void visitRttSub(RttSub* curr); + void visitStructNew(StructNew* curr); + void visitStructGet(StructGet* curr); + void visitStructSet(StructSet* curr); + void visitArrayNew(ArrayNew* curr); + void visitArrayGet(ArrayGet* curr); + void visitArraySet(ArraySet* curr); + void visitArrayLen(ArrayLen* curr); + + void emitResultType(Type type); + void emitIfElse(If* curr); + void emitCatch(Try* curr); + // emit an end at the end of a block/loop/if/try + void emitScopeEnd(Expression* curr); + // emit an end at the end of a function + void emitFunctionEnd(); + void emitUnreachable(); + void mapLocalsAndEmitHeader(); + +private: + void emitMemoryAccess(size_t alignment, size_t bytes, uint32_t offset); + int32_t getBreakIndex(Name name); + + WasmBinaryWriter& parent; + BufferWithRandomAccess& o; + Function* func = nullptr; + bool sourceMap; + bool DWARF; + + std::vector breakStack; + + // type => number of locals of that type in the compact form + std::map numLocalsByType; + // (local index, tuple index) => binary local index + std::map, size_t> mappedLocals; + + // Keeps track of the binary index of the scratch locals used to lower + // tuple.extract. + std::map scratchLocals; + void countScratchLocals(); + void setScratchLocals(); +}; + +// Takes binaryen IR and converts it to something else (binary or stack IR) +template +class BinaryenIRWriter : public Visitor> { +public: + BinaryenIRWriter(Function* func) : func(func) {} + + void write(); + + // visits a node, emitting the proper code for it + void visit(Expression* curr); + + void visitBlock(Block* curr); + void visitIf(If* curr); + void visitLoop(Loop* curr); + void visitTry(Try* curr); + +protected: + Function* func = nullptr; + +private: + void emit(Expression* curr) { static_cast(this)->emit(curr); } + void emitHeader() { static_cast(this)->emitHeader(); } + void emitIfElse(If* curr) { static_cast(this)->emitIfElse(curr); } + void emitCatch(Try* curr) { static_cast(this)->emitCatch(curr); } + void emitScopeEnd(Expression* curr) { + static_cast(this)->emitScopeEnd(curr); + } + void emitFunctionEnd() { static_cast(this)->emitFunctionEnd(); } + void emitUnreachable() { static_cast(this)->emitUnreachable(); } + void emitDebugLocation(Expression* curr) { + static_cast(this)->emitDebugLocation(curr); + } + void visitPossibleBlockContents(Expression* curr); +}; + +template void BinaryenIRWriter::write() { + assert(func && "BinaryenIRWriter: function is not set"); + emitHeader(); + visitPossibleBlockContents(func->body); + emitFunctionEnd(); +} + +// emits a node, but if it is a block with no name, emit a list of its contents +template +void BinaryenIRWriter::visitPossibleBlockContents(Expression* curr) { + auto* block = curr->dynCast(); + if (!block || BranchUtils::BranchSeeker::has(block, block->name)) { + visit(curr); + return; + } + for (auto* child : block->list) { + visit(child); + // Since this child was unreachable, either this child or one of its + // descendants was a source of unreachability that was actually + // emitted. Subsequent children won't be reachable, so skip them. + if (child->type == Type::unreachable) { + break; + } + } +} + +template +void BinaryenIRWriter::visit(Expression* curr) { + emitDebugLocation(curr); + // We emit unreachable instructions that create unreachability, but not + // unreachable instructions that just inherit unreachability from their + // children, since the latter won't be reached. This (together with logic in + // the control flow visitors) also ensures that the final instruction in each + // unreachable block is a source of unreachability, which means we don't need + // to emit an extra `unreachable` before the end of the block to prevent type + // errors. + bool hasUnreachableChild = false; + for (auto* child : ValueChildIterator(curr)) { + visit(child); + if (child->type == Type::unreachable) { + hasUnreachableChild = true; + break; + } + } + if (hasUnreachableChild) { + // `curr` is not reachable, so don't emit it. + return; + } + // Control flow requires special handling, but most instructions can be + // emitted directly after their children. + if (Properties::isControlFlowStructure(curr)) { + Visitor::visit(curr); + } else { + emit(curr); + } +} + +template +void BinaryenIRWriter::visitBlock(Block* curr) { + auto visitChildren = [this](Block* curr, Index from) { + auto& list = curr->list; + while (from < list.size()) { + auto* child = list[from]; + visit(child); + if (child->type == Type::unreachable) { + break; + } + ++from; + } + }; + + auto afterChildren = [this](Block* curr) { + emitScopeEnd(curr); + if (curr->type == Type::unreachable) { + // Since this block is unreachable, no instructions will be emitted after + // it in its enclosing scope. That means that this block will be the last + // instruction before the end of its parent scope, so its type must match + // the type of its parent. But we don't have a concrete type for this + // block and we don't know what type its parent expects, so we can't + // ensure the types match. To work around this, we insert an `unreachable` + // instruction after every unreachable control flow structure and depend + // on its polymorphic behavior to paper over any type mismatches. + emitUnreachable(); + } + }; + + // Handle very deeply nested blocks in the first position efficiently, + // avoiding heavy recursion. We only start to do this if we see it will help + // us (to avoid allocation of the vector). + if (!curr->list.empty() && curr->list[0]->is()) { + std::vector parents; + Block* child; + while (!curr->list.empty() && (child = curr->list[0]->dynCast())) { + parents.push_back(curr); + emit(curr); + curr = child; + } + // Emit the current block, which does not have a block as a child in the + // first position. + emit(curr); + visitChildren(curr, 0); + afterChildren(curr); + bool childUnreachable = curr->type == Type::unreachable; + // Finish the later parts of all the parent blocks. + while (!parents.empty()) { + auto* parent = parents.back(); + parents.pop_back(); + if (!childUnreachable) { + visitChildren(parent, 1); + } + afterChildren(parent); + childUnreachable = parent->type == Type::unreachable; + } + return; + } + // Simple case of not having a nested block in the first position. + emit(curr); + visitChildren(curr, 0); + afterChildren(curr); +} + +template void BinaryenIRWriter::visitIf(If* curr) { + emit(curr); + visitPossibleBlockContents(curr->ifTrue); + + if (curr->ifFalse) { + emitIfElse(curr); + visitPossibleBlockContents(curr->ifFalse); + } + + emitScopeEnd(curr); + if (curr->type == Type::unreachable) { + // We already handled the case of the condition being unreachable in + // `visit`. Otherwise, we may still be unreachable, if we are an if-else + // with both sides unreachable. Just like with blocks, we emit an extra + // `unreachable` to work around potential type mismatches. + assert(curr->ifFalse); + emitUnreachable(); + } +} + +template +void BinaryenIRWriter::visitLoop(Loop* curr) { + emit(curr); + visitPossibleBlockContents(curr->body); + emitScopeEnd(curr); + if (curr->type == Type::unreachable) { + // we emitted a loop without a return type, so it must not be consumed + emitUnreachable(); + } +} + +template void BinaryenIRWriter::visitTry(Try* curr) { + emit(curr); + visitPossibleBlockContents(curr->body); + emitCatch(curr); + visitPossibleBlockContents(curr->catchBody); + emitScopeEnd(curr); + if (curr->type == Type::unreachable) { + emitUnreachable(); + } +} + +// Binaryen IR to binary writer +class BinaryenIRToBinaryWriter + : public BinaryenIRWriter { +public: + BinaryenIRToBinaryWriter(WasmBinaryWriter& parent, + BufferWithRandomAccess& o, + Function* func = nullptr, + bool sourceMap = false, + bool DWARF = false) + : BinaryenIRWriter(func), parent(parent), + writer(parent, o, func, sourceMap, DWARF), sourceMap(sourceMap) {} + + void visit(Expression* curr) { + BinaryenIRWriter::visit(curr); + } + + void emit(Expression* curr) { writer.visit(curr); } + void emitHeader() { + if (func->prologLocation.size()) { + parent.writeDebugLocation(*func->prologLocation.begin()); + } + writer.mapLocalsAndEmitHeader(); + } + void emitIfElse(If* curr) { writer.emitIfElse(curr); } + void emitCatch(Try* curr) { writer.emitCatch(curr); } + void emitScopeEnd(Expression* curr) { writer.emitScopeEnd(curr); } + void emitFunctionEnd() { + if (func->epilogLocation.size()) { + parent.writeDebugLocation(*func->epilogLocation.begin()); + } + writer.emitFunctionEnd(); + } + void emitUnreachable() { writer.emitUnreachable(); } + void emitDebugLocation(Expression* curr) { + if (sourceMap) { + parent.writeDebugLocation(curr, func); + } + } + +private: + WasmBinaryWriter& parent; + BinaryInstWriter writer; + bool sourceMap; +}; + +// Binaryen IR to stack IR converter +// Queues the expressions linearly in Stack IR (SIR) +class StackIRGenerator : public BinaryenIRWriter { +public: + StackIRGenerator(Module& module, Function* func) + : BinaryenIRWriter(func), module(module) {} + + void emit(Expression* curr); + void emitScopeEnd(Expression* curr); + void emitHeader() {} + void emitIfElse(If* curr) { + stackIR.push_back(makeStackInst(StackInst::IfElse, curr)); + } + void emitCatch(Try* curr) { + stackIR.push_back(makeStackInst(StackInst::Catch, curr)); + } + void emitFunctionEnd() {} + void emitUnreachable() { + stackIR.push_back(makeStackInst(Builder(module).makeUnreachable())); + } + void emitDebugLocation(Expression* curr) {} + + StackIR& getStackIR() { return stackIR; } + +private: + StackInst* makeStackInst(StackInst::Op op, Expression* origin); + StackInst* makeStackInst(Expression* origin) { + return makeStackInst(StackInst::Basic, origin); + } + + Module& module; + StackIR stackIR; // filled in write() +}; + +// Stack IR to binary writer +class StackIRToBinaryWriter { +public: + StackIRToBinaryWriter(WasmBinaryWriter& parent, + BufferWithRandomAccess& o, + Function* func) + : writer(parent, o, func, false /* sourceMap */, false /* DWARF */), + func(func) {} + + void write(); + +private: + BinaryInstWriter writer; + Function* func; +}; + +} // namespace wasm + +#endif // wasm_stack_h diff --git a/binaryen/src/wasm-traversal.h b/binaryen/src/wasm-traversal.h new file mode 100644 --- /dev/null +++ b/binaryen/src/wasm-traversal.h @@ -0,0 +1,1669 @@ +/* + * Copyright 2016 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// WebAssembly AST visitor. Useful for anything that wants to do something +// different for each AST node type, like printing, interpreting, etc. +// +// This class is specifically designed as a template to avoid virtual function +// call overhead. To write a visitor, derive from this class as follows: +// +// struct MyVisitor : public WasmVisitor { .. } +// + +#ifndef wasm_wasm_traversal_h +#define wasm_wasm_traversal_h + +#include "support/small_vector.h" +#include "support/threads.h" +#include "wasm.h" + +namespace wasm { + +// A generic visitor, defaulting to doing nothing on each visit + +template struct Visitor { + // Expression visitors + ReturnType visitBlock(Block* curr) { return ReturnType(); } + ReturnType visitIf(If* curr) { return ReturnType(); } + ReturnType visitLoop(Loop* curr) { return ReturnType(); } + ReturnType visitBreak(Break* curr) { return ReturnType(); } + ReturnType visitSwitch(Switch* curr) { return ReturnType(); } + ReturnType visitCall(Call* curr) { return ReturnType(); } + ReturnType visitCallIndirect(CallIndirect* curr) { return ReturnType(); } + ReturnType visitLocalGet(LocalGet* curr) { return ReturnType(); } + ReturnType visitLocalSet(LocalSet* curr) { return ReturnType(); } + ReturnType visitGlobalGet(GlobalGet* curr) { return ReturnType(); } + ReturnType visitGlobalSet(GlobalSet* curr) { return ReturnType(); } + ReturnType visitLoad(Load* curr) { return ReturnType(); } + ReturnType visitStore(Store* curr) { return ReturnType(); } + ReturnType visitAtomicRMW(AtomicRMW* curr) { return ReturnType(); } + ReturnType visitAtomicCmpxchg(AtomicCmpxchg* curr) { return ReturnType(); } + ReturnType visitAtomicWait(AtomicWait* curr) { return ReturnType(); } + ReturnType visitAtomicNotify(AtomicNotify* curr) { return ReturnType(); } + ReturnType visitAtomicFence(AtomicFence* curr) { return ReturnType(); } + ReturnType visitSIMDExtract(SIMDExtract* curr) { return ReturnType(); } + ReturnType visitSIMDReplace(SIMDReplace* curr) { return ReturnType(); } + ReturnType visitSIMDShuffle(SIMDShuffle* curr) { return ReturnType(); } + ReturnType visitSIMDTernary(SIMDTernary* curr) { return ReturnType(); } + ReturnType visitSIMDShift(SIMDShift* curr) { return ReturnType(); } + ReturnType visitSIMDLoad(SIMDLoad* curr) { return ReturnType(); } + ReturnType visitMemoryInit(MemoryInit* curr) { return ReturnType(); } + ReturnType visitDataDrop(DataDrop* curr) { return ReturnType(); } + ReturnType visitMemoryCopy(MemoryCopy* curr) { return ReturnType(); } + ReturnType visitMemoryFill(MemoryFill* curr) { return ReturnType(); } + ReturnType visitConst(Const* curr) { return ReturnType(); } + ReturnType visitUnary(Unary* curr) { return ReturnType(); } + ReturnType visitBinary(Binary* curr) { return ReturnType(); } + ReturnType visitSelect(Select* curr) { return ReturnType(); } + ReturnType visitDrop(Drop* curr) { return ReturnType(); } + ReturnType visitReturn(Return* curr) { return ReturnType(); } + ReturnType visitMemorySize(MemorySize* curr) { return ReturnType(); } + ReturnType visitMemoryGrow(MemoryGrow* curr) { return ReturnType(); } + ReturnType visitRefNull(RefNull* curr) { return ReturnType(); } + ReturnType visitRefIsNull(RefIsNull* curr) { return ReturnType(); } + ReturnType visitRefFunc(RefFunc* curr) { return ReturnType(); } + ReturnType visitRefEq(RefEq* curr) { return ReturnType(); } + ReturnType visitTry(Try* curr) { return ReturnType(); } + ReturnType visitThrow(Throw* curr) { return ReturnType(); } + ReturnType visitRethrow(Rethrow* curr) { return ReturnType(); } + ReturnType visitBrOnExn(BrOnExn* curr) { return ReturnType(); } + ReturnType visitNop(Nop* curr) { return ReturnType(); } + ReturnType visitUnreachable(Unreachable* curr) { return ReturnType(); } + ReturnType visitPop(Pop* curr) { return ReturnType(); } + ReturnType visitTupleMake(TupleMake* curr) { return ReturnType(); } + ReturnType visitTupleExtract(TupleExtract* curr) { return ReturnType(); } + ReturnType visitI31New(I31New* curr) { return ReturnType(); } + ReturnType visitI31Get(I31Get* curr) { return ReturnType(); } + ReturnType visitRefTest(RefTest* curr) { return ReturnType(); } + ReturnType visitRefCast(RefCast* curr) { return ReturnType(); } + ReturnType visitBrOnCast(BrOnCast* curr) { return ReturnType(); } + ReturnType visitRttCanon(RttCanon* curr) { return ReturnType(); } + ReturnType visitRttSub(RttSub* curr) { return ReturnType(); } + ReturnType visitStructNew(StructNew* curr) { return ReturnType(); } + ReturnType visitStructGet(StructGet* curr) { return ReturnType(); } + ReturnType visitStructSet(StructSet* curr) { return ReturnType(); } + ReturnType visitArrayNew(ArrayNew* curr) { return ReturnType(); } + ReturnType visitArrayGet(ArrayGet* curr) { return ReturnType(); } + ReturnType visitArraySet(ArraySet* curr) { return ReturnType(); } + ReturnType visitArrayLen(ArrayLen* curr) { return ReturnType(); } + // Module-level visitors + ReturnType visitExport(Export* curr) { return ReturnType(); } + ReturnType visitGlobal(Global* curr) { return ReturnType(); } + ReturnType visitFunction(Function* curr) { return ReturnType(); } + ReturnType visitTable(Table* curr) { return ReturnType(); } + ReturnType visitMemory(Memory* curr) { return ReturnType(); } + ReturnType visitEvent(Event* curr) { return ReturnType(); } + ReturnType visitModule(Module* curr) { return ReturnType(); } + + ReturnType visit(Expression* curr) { + assert(curr); + +#define DELEGATE(CLASS_TO_VISIT) \ + return static_cast(this)->visit##CLASS_TO_VISIT( \ + static_cast(curr)) + + switch (curr->_id) { + case Expression::Id::BlockId: + DELEGATE(Block); + case Expression::Id::IfId: + DELEGATE(If); + case Expression::Id::LoopId: + DELEGATE(Loop); + case Expression::Id::BreakId: + DELEGATE(Break); + case Expression::Id::SwitchId: + DELEGATE(Switch); + case Expression::Id::CallId: + DELEGATE(Call); + case Expression::Id::CallIndirectId: + DELEGATE(CallIndirect); + case Expression::Id::LocalGetId: + DELEGATE(LocalGet); + case Expression::Id::LocalSetId: + DELEGATE(LocalSet); + case Expression::Id::GlobalGetId: + DELEGATE(GlobalGet); + case Expression::Id::GlobalSetId: + DELEGATE(GlobalSet); + case Expression::Id::LoadId: + DELEGATE(Load); + case Expression::Id::StoreId: + DELEGATE(Store); + case Expression::Id::AtomicRMWId: + DELEGATE(AtomicRMW); + case Expression::Id::AtomicCmpxchgId: + DELEGATE(AtomicCmpxchg); + case Expression::Id::AtomicWaitId: + DELEGATE(AtomicWait); + case Expression::Id::AtomicNotifyId: + DELEGATE(AtomicNotify); + case Expression::Id::AtomicFenceId: + DELEGATE(AtomicFence); + case Expression::Id::SIMDExtractId: + DELEGATE(SIMDExtract); + case Expression::Id::SIMDReplaceId: + DELEGATE(SIMDReplace); + case Expression::Id::SIMDShuffleId: + DELEGATE(SIMDShuffle); + case Expression::Id::SIMDTernaryId: + DELEGATE(SIMDTernary); + case Expression::Id::SIMDShiftId: + DELEGATE(SIMDShift); + case Expression::Id::SIMDLoadId: + DELEGATE(SIMDLoad); + case Expression::Id::MemoryInitId: + DELEGATE(MemoryInit); + case Expression::Id::DataDropId: + DELEGATE(DataDrop); + case Expression::Id::MemoryCopyId: + DELEGATE(MemoryCopy); + case Expression::Id::MemoryFillId: + DELEGATE(MemoryFill); + case Expression::Id::ConstId: + DELEGATE(Const); + case Expression::Id::UnaryId: + DELEGATE(Unary); + case Expression::Id::BinaryId: + DELEGATE(Binary); + case Expression::Id::SelectId: + DELEGATE(Select); + case Expression::Id::DropId: + DELEGATE(Drop); + case Expression::Id::ReturnId: + DELEGATE(Return); + case Expression::Id::MemorySizeId: + DELEGATE(MemorySize); + case Expression::Id::MemoryGrowId: + DELEGATE(MemoryGrow); + case Expression::Id::RefNullId: + DELEGATE(RefNull); + case Expression::Id::RefIsNullId: + DELEGATE(RefIsNull); + case Expression::Id::RefFuncId: + DELEGATE(RefFunc); + case Expression::Id::RefEqId: + DELEGATE(RefEq); + case Expression::Id::TryId: + DELEGATE(Try); + case Expression::Id::ThrowId: + DELEGATE(Throw); + case Expression::Id::RethrowId: + DELEGATE(Rethrow); + case Expression::Id::BrOnExnId: + DELEGATE(BrOnExn); + case Expression::Id::NopId: + DELEGATE(Nop); + case Expression::Id::UnreachableId: + DELEGATE(Unreachable); + case Expression::Id::PopId: + DELEGATE(Pop); + case Expression::Id::TupleMakeId: + DELEGATE(TupleMake); + case Expression::Id::TupleExtractId: + DELEGATE(TupleExtract); + case Expression::Id::I31NewId: + DELEGATE(I31New); + case Expression::Id::I31GetId: + DELEGATE(I31Get); + case Expression::Id::RefTestId: + DELEGATE(RefTest); + case Expression::Id::RefCastId: + DELEGATE(RefCast); + case Expression::Id::BrOnCastId: + DELEGATE(BrOnCast); + case Expression::Id::RttCanonId: + DELEGATE(RttCanon); + case Expression::Id::RttSubId: + DELEGATE(RttSub); + case Expression::Id::StructNewId: + DELEGATE(StructNew); + case Expression::Id::StructGetId: + DELEGATE(StructGet); + case Expression::Id::StructSetId: + DELEGATE(StructSet); + case Expression::Id::ArrayNewId: + DELEGATE(ArrayNew); + case Expression::Id::ArrayGetId: + DELEGATE(ArrayGet); + case Expression::Id::ArraySetId: + DELEGATE(ArraySet); + case Expression::Id::ArrayLenId: + DELEGATE(ArrayLen); + case Expression::Id::InvalidId: + default: + WASM_UNREACHABLE("unexpected expression type"); + } + +#undef DELEGATE + } +}; + +// A visitor which must be overridden for each visitor that is reached. + +template +struct OverriddenVisitor { +// Expression visitors, which must be overridden +#define UNIMPLEMENTED(CLASS_TO_VISIT) \ + ReturnType visit##CLASS_TO_VISIT(CLASS_TO_VISIT* curr) { \ + static_assert( \ + &SubType::visit##CLASS_TO_VISIT != \ + &OverriddenVisitor::visit##CLASS_TO_VISIT, \ + "Derived class must implement visit" #CLASS_TO_VISIT); \ + WASM_UNREACHABLE("Derived class must implement visit" #CLASS_TO_VISIT); \ + } + + UNIMPLEMENTED(Block); + UNIMPLEMENTED(If); + UNIMPLEMENTED(Loop); + UNIMPLEMENTED(Break); + UNIMPLEMENTED(Switch); + UNIMPLEMENTED(Call); + UNIMPLEMENTED(CallIndirect); + UNIMPLEMENTED(LocalGet); + UNIMPLEMENTED(LocalSet); + UNIMPLEMENTED(GlobalGet); + UNIMPLEMENTED(GlobalSet); + UNIMPLEMENTED(Load); + UNIMPLEMENTED(Store); + UNIMPLEMENTED(AtomicRMW); + UNIMPLEMENTED(AtomicCmpxchg); + UNIMPLEMENTED(AtomicWait); + UNIMPLEMENTED(AtomicNotify); + UNIMPLEMENTED(AtomicFence); + UNIMPLEMENTED(SIMDExtract); + UNIMPLEMENTED(SIMDReplace); + UNIMPLEMENTED(SIMDShuffle); + UNIMPLEMENTED(SIMDTernary); + UNIMPLEMENTED(SIMDShift); + UNIMPLEMENTED(SIMDLoad); + UNIMPLEMENTED(MemoryInit); + UNIMPLEMENTED(DataDrop); + UNIMPLEMENTED(MemoryCopy); + UNIMPLEMENTED(MemoryFill); + UNIMPLEMENTED(Const); + UNIMPLEMENTED(Unary); + UNIMPLEMENTED(Binary); + UNIMPLEMENTED(Select); + UNIMPLEMENTED(Drop); + UNIMPLEMENTED(Return); + UNIMPLEMENTED(MemorySize); + UNIMPLEMENTED(MemoryGrow); + UNIMPLEMENTED(RefNull); + UNIMPLEMENTED(RefIsNull); + UNIMPLEMENTED(RefFunc); + UNIMPLEMENTED(RefEq); + UNIMPLEMENTED(Try); + UNIMPLEMENTED(Throw); + UNIMPLEMENTED(Rethrow); + UNIMPLEMENTED(BrOnExn); + UNIMPLEMENTED(Nop); + UNIMPLEMENTED(Unreachable); + UNIMPLEMENTED(Pop); + UNIMPLEMENTED(TupleMake); + UNIMPLEMENTED(TupleExtract); + UNIMPLEMENTED(I31New); + UNIMPLEMENTED(I31Get); + UNIMPLEMENTED(RefTest); + UNIMPLEMENTED(RefCast); + UNIMPLEMENTED(BrOnCast); + UNIMPLEMENTED(RttCanon); + UNIMPLEMENTED(RttSub); + UNIMPLEMENTED(StructNew); + UNIMPLEMENTED(StructGet); + UNIMPLEMENTED(StructSet); + UNIMPLEMENTED(ArrayNew); + UNIMPLEMENTED(ArrayGet); + UNIMPLEMENTED(ArraySet); + UNIMPLEMENTED(ArrayLen); + UNIMPLEMENTED(Export); + UNIMPLEMENTED(Global); + UNIMPLEMENTED(Function); + UNIMPLEMENTED(Table); + UNIMPLEMENTED(Memory); + UNIMPLEMENTED(Event); + UNIMPLEMENTED(Module); + +#undef UNIMPLEMENTED + + ReturnType visit(Expression* curr) { + assert(curr); + +#define DELEGATE(CLASS_TO_VISIT) \ + return static_cast(this)->visit##CLASS_TO_VISIT( \ + static_cast(curr)) + + switch (curr->_id) { + case Expression::Id::BlockId: + DELEGATE(Block); + case Expression::Id::IfId: + DELEGATE(If); + case Expression::Id::LoopId: + DELEGATE(Loop); + case Expression::Id::BreakId: + DELEGATE(Break); + case Expression::Id::SwitchId: + DELEGATE(Switch); + case Expression::Id::CallId: + DELEGATE(Call); + case Expression::Id::CallIndirectId: + DELEGATE(CallIndirect); + case Expression::Id::LocalGetId: + DELEGATE(LocalGet); + case Expression::Id::LocalSetId: + DELEGATE(LocalSet); + case Expression::Id::GlobalGetId: + DELEGATE(GlobalGet); + case Expression::Id::GlobalSetId: + DELEGATE(GlobalSet); + case Expression::Id::LoadId: + DELEGATE(Load); + case Expression::Id::StoreId: + DELEGATE(Store); + case Expression::Id::AtomicRMWId: + DELEGATE(AtomicRMW); + case Expression::Id::AtomicCmpxchgId: + DELEGATE(AtomicCmpxchg); + case Expression::Id::AtomicWaitId: + DELEGATE(AtomicWait); + case Expression::Id::AtomicNotifyId: + DELEGATE(AtomicNotify); + case Expression::Id::AtomicFenceId: + DELEGATE(AtomicFence); + case Expression::Id::SIMDExtractId: + DELEGATE(SIMDExtract); + case Expression::Id::SIMDReplaceId: + DELEGATE(SIMDReplace); + case Expression::Id::SIMDShuffleId: + DELEGATE(SIMDShuffle); + case Expression::Id::SIMDTernaryId: + DELEGATE(SIMDTernary); + case Expression::Id::SIMDShiftId: + DELEGATE(SIMDShift); + case Expression::Id::SIMDLoadId: + DELEGATE(SIMDLoad); + case Expression::Id::MemoryInitId: + DELEGATE(MemoryInit); + case Expression::Id::DataDropId: + DELEGATE(DataDrop); + case Expression::Id::MemoryCopyId: + DELEGATE(MemoryCopy); + case Expression::Id::MemoryFillId: + DELEGATE(MemoryFill); + case Expression::Id::ConstId: + DELEGATE(Const); + case Expression::Id::UnaryId: + DELEGATE(Unary); + case Expression::Id::BinaryId: + DELEGATE(Binary); + case Expression::Id::SelectId: + DELEGATE(Select); + case Expression::Id::DropId: + DELEGATE(Drop); + case Expression::Id::ReturnId: + DELEGATE(Return); + case Expression::Id::MemorySizeId: + DELEGATE(MemorySize); + case Expression::Id::MemoryGrowId: + DELEGATE(MemoryGrow); + case Expression::Id::RefNullId: + DELEGATE(RefNull); + case Expression::Id::RefIsNullId: + DELEGATE(RefIsNull); + case Expression::Id::RefFuncId: + DELEGATE(RefFunc); + case Expression::Id::RefEqId: + DELEGATE(RefEq); + case Expression::Id::TryId: + DELEGATE(Try); + case Expression::Id::ThrowId: + DELEGATE(Throw); + case Expression::Id::RethrowId: + DELEGATE(Rethrow); + case Expression::Id::BrOnExnId: + DELEGATE(BrOnExn); + case Expression::Id::NopId: + DELEGATE(Nop); + case Expression::Id::UnreachableId: + DELEGATE(Unreachable); + case Expression::Id::PopId: + DELEGATE(Pop); + case Expression::Id::TupleMakeId: + DELEGATE(TupleMake); + case Expression::Id::TupleExtractId: + DELEGATE(TupleExtract); + case Expression::Id::I31NewId: + DELEGATE(I31New); + case Expression::Id::I31GetId: + DELEGATE(I31Get); + case Expression::Id::RefTestId: + DELEGATE(RefTest); + case Expression::Id::RefCastId: + DELEGATE(RefCast); + case Expression::Id::BrOnCastId: + DELEGATE(BrOnCast); + case Expression::Id::RttCanonId: + DELEGATE(RttCanon); + case Expression::Id::RttSubId: + DELEGATE(RttSub); + case Expression::Id::StructNewId: + DELEGATE(StructNew); + case Expression::Id::StructGetId: + DELEGATE(StructGet); + case Expression::Id::StructSetId: + DELEGATE(StructSet); + case Expression::Id::ArrayNewId: + DELEGATE(ArrayNew); + case Expression::Id::ArrayGetId: + DELEGATE(ArrayGet); + case Expression::Id::ArraySetId: + DELEGATE(ArraySet); + case Expression::Id::ArrayLenId: + DELEGATE(ArrayLen); + case Expression::Id::InvalidId: + default: + WASM_UNREACHABLE("unexpected expression type"); + } + +#undef DELEGATE + } +}; + +// Visit with a single unified visitor, called on every node, instead of +// separate visit* per node + +template +struct UnifiedExpressionVisitor : public Visitor { + // called on each node + ReturnType visitExpression(Expression* curr) { return ReturnType(); } + + // redirects + ReturnType visitBlock(Block* curr) { + return static_cast(this)->visitExpression(curr); + } + ReturnType visitIf(If* curr) { + return static_cast(this)->visitExpression(curr); + } + ReturnType visitLoop(Loop* curr) { + return static_cast(this)->visitExpression(curr); + } + ReturnType visitBreak(Break* curr) { + return static_cast(this)->visitExpression(curr); + } + ReturnType visitSwitch(Switch* curr) { + return static_cast(this)->visitExpression(curr); + } + ReturnType visitCall(Call* curr) { + return static_cast(this)->visitExpression(curr); + } + ReturnType visitCallIndirect(CallIndirect* curr) { + return static_cast(this)->visitExpression(curr); + } + ReturnType visitLocalGet(LocalGet* curr) { + return static_cast(this)->visitExpression(curr); + } + ReturnType visitLocalSet(LocalSet* curr) { + return static_cast(this)->visitExpression(curr); + } + ReturnType visitGlobalGet(GlobalGet* curr) { + return static_cast(this)->visitExpression(curr); + } + ReturnType visitGlobalSet(GlobalSet* curr) { + return static_cast(this)->visitExpression(curr); + } + ReturnType visitLoad(Load* curr) { + return static_cast(this)->visitExpression(curr); + } + ReturnType visitStore(Store* curr) { + return static_cast(this)->visitExpression(curr); + } + ReturnType visitAtomicRMW(AtomicRMW* curr) { + return static_cast(this)->visitExpression(curr); + } + ReturnType visitAtomicCmpxchg(AtomicCmpxchg* curr) { + return static_cast(this)->visitExpression(curr); + } + ReturnType visitAtomicWait(AtomicWait* curr) { + return static_cast(this)->visitExpression(curr); + } + ReturnType visitAtomicNotify(AtomicNotify* curr) { + return static_cast(this)->visitExpression(curr); + } + ReturnType visitAtomicFence(AtomicFence* curr) { + return static_cast(this)->visitExpression(curr); + } + ReturnType visitSIMDExtract(SIMDExtract* curr) { + return static_cast(this)->visitExpression(curr); + } + ReturnType visitSIMDReplace(SIMDReplace* curr) { + return static_cast(this)->visitExpression(curr); + } + ReturnType visitSIMDShuffle(SIMDShuffle* curr) { + return static_cast(this)->visitExpression(curr); + } + ReturnType visitSIMDTernary(SIMDTernary* curr) { + return static_cast(this)->visitExpression(curr); + } + ReturnType visitSIMDShift(SIMDShift* curr) { + return static_cast(this)->visitExpression(curr); + } + ReturnType visitSIMDLoad(SIMDLoad* curr) { + return static_cast(this)->visitExpression(curr); + } + ReturnType visitMemoryInit(MemoryInit* curr) { + return static_cast(this)->visitExpression(curr); + } + ReturnType visitDataDrop(DataDrop* curr) { + return static_cast(this)->visitExpression(curr); + } + ReturnType visitMemoryCopy(MemoryCopy* curr) { + return static_cast(this)->visitExpression(curr); + } + ReturnType visitMemoryFill(MemoryFill* curr) { + return static_cast(this)->visitExpression(curr); + } + ReturnType visitConst(Const* curr) { + return static_cast(this)->visitExpression(curr); + } + ReturnType visitUnary(Unary* curr) { + return static_cast(this)->visitExpression(curr); + } + ReturnType visitBinary(Binary* curr) { + return static_cast(this)->visitExpression(curr); + } + ReturnType visitSelect(Select* curr) { + return static_cast(this)->visitExpression(curr); + } + ReturnType visitDrop(Drop* curr) { + return static_cast(this)->visitExpression(curr); + } + ReturnType visitReturn(Return* curr) { + return static_cast(this)->visitExpression(curr); + } + ReturnType visitMemorySize(MemorySize* curr) { + return static_cast(this)->visitExpression(curr); + } + ReturnType visitMemoryGrow(MemoryGrow* curr) { + return static_cast(this)->visitExpression(curr); + } + ReturnType visitRefNull(RefNull* curr) { + return static_cast(this)->visitExpression(curr); + } + ReturnType visitRefIsNull(RefIsNull* curr) { + return static_cast(this)->visitExpression(curr); + } + ReturnType visitRefFunc(RefFunc* curr) { + return static_cast(this)->visitExpression(curr); + } + ReturnType visitRefEq(RefEq* curr) { + return static_cast(this)->visitExpression(curr); + } + ReturnType visitTry(Try* curr) { + return static_cast(this)->visitExpression(curr); + } + ReturnType visitThrow(Throw* curr) { + return static_cast(this)->visitExpression(curr); + } + ReturnType visitRethrow(Rethrow* curr) { + return static_cast(this)->visitExpression(curr); + } + ReturnType visitBrOnExn(BrOnExn* curr) { + return static_cast(this)->visitExpression(curr); + } + ReturnType visitNop(Nop* curr) { + return static_cast(this)->visitExpression(curr); + } + ReturnType visitUnreachable(Unreachable* curr) { + return static_cast(this)->visitExpression(curr); + } + ReturnType visitPop(Pop* curr) { + return static_cast(this)->visitExpression(curr); + } + ReturnType visitTupleMake(TupleMake* curr) { + return static_cast(this)->visitExpression(curr); + } + ReturnType visitTupleExtract(TupleExtract* curr) { + return static_cast(this)->visitExpression(curr); + } + ReturnType visitI31New(I31New* curr) { + return static_cast(this)->visitExpression(curr); + } + ReturnType visitI31Get(I31Get* curr) { + return static_cast(this)->visitExpression(curr); + } + ReturnType visitRefTest(RefTest* curr) { + return static_cast(this)->visitExpression(curr); + } + ReturnType visitRefCast(RefCast* curr) { + return static_cast(this)->visitExpression(curr); + } + ReturnType visitBrOnCast(BrOnCast* curr) { + return static_cast(this)->visitExpression(curr); + } + ReturnType visitRttCanon(RttCanon* curr) { + return static_cast(this)->visitExpression(curr); + } + ReturnType visitRttSub(RttSub* curr) { + return static_cast(this)->visitExpression(curr); + } + ReturnType visitStructNew(StructNew* curr) { + return static_cast(this)->visitExpression(curr); + } + ReturnType visitStructGet(StructGet* curr) { + return static_cast(this)->visitExpression(curr); + } + ReturnType visitStructSet(StructSet* curr) { + return static_cast(this)->visitExpression(curr); + } + ReturnType visitArrayNew(ArrayNew* curr) { + return static_cast(this)->visitExpression(curr); + } + ReturnType visitArrayGet(ArrayGet* curr) { + return static_cast(this)->visitExpression(curr); + } + ReturnType visitArraySet(ArraySet* curr) { + return static_cast(this)->visitExpression(curr); + } + ReturnType visitArrayLen(ArrayLen* curr) { + return static_cast(this)->visitExpression(curr); + } +}; + +// +// Base class for all WasmWalkers, which can traverse an AST +// and provide the option to replace nodes while doing so. +// +// Subclass and implement the visit*() +// calls to run code on different node types. +// +template +struct Walker : public VisitorType { + // Useful methods for visitor implementions + + // Replace the current node. You can call this in your visit*() methods. + // Note that the visit*() for the result node is not called for you (i.e., + // just one visit*() method is called by the traversal; if you replace a node, + // and you want to process the output, you must do that explicitly). + Expression* replaceCurrent(Expression* expression) { + // Copy debug info, if present. + if (currFunction) { + auto& debugLocations = currFunction->debugLocations; + if (!debugLocations.empty()) { + auto* curr = getCurrent(); + auto iter = debugLocations.find(curr); + if (iter != debugLocations.end()) { + auto location = iter->second; + debugLocations.erase(iter); + debugLocations[expression] = location; + } + } + } + return *replacep = expression; + } + + Expression* getCurrent() { return *replacep; } + + Expression** getCurrentPointer() { return replacep; } + + // Get the current module + Module* getModule() { return currModule; } + + // Get the current function + Function* getFunction() { return currFunction; } + + // Walk starting + + void walkGlobal(Global* global) { + walk(global->init); + static_cast(this)->visitGlobal(global); + } + + void walkFunction(Function* func) { + setFunction(func); + static_cast(this)->doWalkFunction(func); + static_cast(this)->visitFunction(func); + setFunction(nullptr); + } + + void walkEvent(Event* event) { + static_cast(this)->visitEvent(event); + } + + void walkFunctionInModule(Function* func, Module* module) { + setModule(module); + setFunction(func); + static_cast(this)->doWalkFunction(func); + static_cast(this)->visitFunction(func); + setFunction(nullptr); + setModule(nullptr); + } + + // override this to provide custom functionality + void doWalkFunction(Function* func) { walk(func->body); } + + void walkTable(Table* table) { + for (auto& segment : table->segments) { + walk(segment.offset); + } + static_cast(this)->visitTable(table); + } + + void walkMemory(Memory* memory) { + for (auto& segment : memory->segments) { + if (!segment.isPassive) { + walk(segment.offset); + } + } + static_cast(this)->visitMemory(memory); + } + + void walkModule(Module* module) { + setModule(module); + static_cast(this)->doWalkModule(module); + static_cast(this)->visitModule(module); + setModule(nullptr); + } + + // override this to provide custom functionality + void doWalkModule(Module* module) { + // Dispatch statically through the SubType. + SubType* self = static_cast(this); + for (auto& curr : module->exports) { + self->visitExport(curr.get()); + } + for (auto& curr : module->globals) { + if (curr->imported()) { + self->visitGlobal(curr.get()); + } else { + self->walkGlobal(curr.get()); + } + } + for (auto& curr : module->functions) { + if (curr->imported()) { + self->visitFunction(curr.get()); + } else { + self->walkFunction(curr.get()); + } + } + for (auto& curr : module->events) { + if (curr->imported()) { + self->visitEvent(curr.get()); + } else { + self->walkEvent(curr.get()); + } + } + self->walkTable(&module->table); + self->walkMemory(&module->memory); + } + + // Walk implementation. We don't use recursion as ASTs may be highly + // nested. + + // Tasks receive the this pointer and a pointer to the pointer to operate on + typedef void (*TaskFunc)(SubType*, Expression**); + + struct Task { + TaskFunc func; + Expression** currp; + Task() {} + Task(TaskFunc func, Expression** currp) : func(func), currp(currp) {} + }; + + void pushTask(TaskFunc func, Expression** currp) { + assert(*currp); + stack.emplace_back(func, currp); + } + void maybePushTask(TaskFunc func, Expression** currp) { + if (*currp) { + stack.emplace_back(func, currp); + } + } + Task popTask() { + auto ret = stack.back(); + stack.pop_back(); + return ret; + } + + void walk(Expression*& root) { + assert(stack.size() == 0); + pushTask(SubType::scan, &root); + while (stack.size() > 0) { + auto task = popTask(); + replacep = task.currp; + assert(*task.currp); + task.func(static_cast(this), task.currp); + } + } + + // subclasses implement this to define the proper order of execution + static void scan(SubType* self, Expression** currp) { abort(); } + + // task hooks to call visitors + + static void doVisitBlock(SubType* self, Expression** currp) { + self->visitBlock((*currp)->cast()); + } + static void doVisitIf(SubType* self, Expression** currp) { + self->visitIf((*currp)->cast()); + } + static void doVisitLoop(SubType* self, Expression** currp) { + self->visitLoop((*currp)->cast()); + } + static void doVisitBreak(SubType* self, Expression** currp) { + self->visitBreak((*currp)->cast()); + } + static void doVisitSwitch(SubType* self, Expression** currp) { + self->visitSwitch((*currp)->cast()); + } + static void doVisitCall(SubType* self, Expression** currp) { + self->visitCall((*currp)->cast()); + } + static void doVisitCallIndirect(SubType* self, Expression** currp) { + self->visitCallIndirect((*currp)->cast()); + } + static void doVisitLocalGet(SubType* self, Expression** currp) { + self->visitLocalGet((*currp)->cast()); + } + static void doVisitLocalSet(SubType* self, Expression** currp) { + self->visitLocalSet((*currp)->cast()); + } + static void doVisitGlobalGet(SubType* self, Expression** currp) { + self->visitGlobalGet((*currp)->cast()); + } + static void doVisitGlobalSet(SubType* self, Expression** currp) { + self->visitGlobalSet((*currp)->cast()); + } + static void doVisitLoad(SubType* self, Expression** currp) { + self->visitLoad((*currp)->cast()); + } + static void doVisitStore(SubType* self, Expression** currp) { + self->visitStore((*currp)->cast()); + } + static void doVisitAtomicRMW(SubType* self, Expression** currp) { + self->visitAtomicRMW((*currp)->cast()); + } + static void doVisitAtomicCmpxchg(SubType* self, Expression** currp) { + self->visitAtomicCmpxchg((*currp)->cast()); + } + static void doVisitAtomicWait(SubType* self, Expression** currp) { + self->visitAtomicWait((*currp)->cast()); + } + static void doVisitAtomicNotify(SubType* self, Expression** currp) { + self->visitAtomicNotify((*currp)->cast()); + } + static void doVisitAtomicFence(SubType* self, Expression** currp) { + self->visitAtomicFence((*currp)->cast()); + } + static void doVisitSIMDExtract(SubType* self, Expression** currp) { + self->visitSIMDExtract((*currp)->cast()); + } + static void doVisitSIMDReplace(SubType* self, Expression** currp) { + self->visitSIMDReplace((*currp)->cast()); + } + static void doVisitSIMDShuffle(SubType* self, Expression** currp) { + self->visitSIMDShuffle((*currp)->cast()); + } + static void doVisitSIMDTernary(SubType* self, Expression** currp) { + self->visitSIMDTernary((*currp)->cast()); + } + static void doVisitSIMDShift(SubType* self, Expression** currp) { + self->visitSIMDShift((*currp)->cast()); + } + static void doVisitSIMDLoad(SubType* self, Expression** currp) { + self->visitSIMDLoad((*currp)->cast()); + } + static void doVisitMemoryInit(SubType* self, Expression** currp) { + self->visitMemoryInit((*currp)->cast()); + } + static void doVisitDataDrop(SubType* self, Expression** currp) { + self->visitDataDrop((*currp)->cast()); + } + static void doVisitMemoryCopy(SubType* self, Expression** currp) { + self->visitMemoryCopy((*currp)->cast()); + } + static void doVisitMemoryFill(SubType* self, Expression** currp) { + self->visitMemoryFill((*currp)->cast()); + } + static void doVisitConst(SubType* self, Expression** currp) { + self->visitConst((*currp)->cast()); + } + static void doVisitUnary(SubType* self, Expression** currp) { + self->visitUnary((*currp)->cast()); + } + static void doVisitBinary(SubType* self, Expression** currp) { + self->visitBinary((*currp)->cast()); + } + static void doVisitSelect(SubType* self, Expression** currp) { + self->visitSelect((*currp)->cast()->condition); + self->pushTask(SubType::scan, &curr->cast()->ifTrue); + break; + } + case Expression::Id::DropId: { + self->pushTask(SubType::doVisitDrop, currp); + self->pushTask(SubType::scan, &curr->cast()->value); + break; + } + case Expression::Id::ReturnId: { + self->pushTask(SubType::doVisitReturn, currp); + self->maybePushTask(SubType::scan, &curr->cast()->value); + break; + } + case Expression::Id::MemorySizeId: + self->pushTask(SubType::doVisitMemorySize, currp); + break; + case Expression::Id::MemoryGrowId: + self->pushTask(SubType::doVisitMemoryGrow, currp); + self->pushTask(SubType::scan, &curr->cast()->delta); + break; + case Expression::Id::RefNullId: { + self->pushTask(SubType::doVisitRefNull, currp); + break; + } + case Expression::Id::RefIsNullId: { + self->pushTask(SubType::doVisitRefIsNull, currp); + self->pushTask(SubType::scan, &curr->cast()->value); + break; + } + case Expression::Id::RefFuncId: { + self->pushTask(SubType::doVisitRefFunc, currp); + break; + } + case Expression::Id::RefEqId: { + self->pushTask(SubType::doVisitRefEq, currp); + self->pushTask(SubType::scan, &curr->cast()->right); + self->pushTask(SubType::scan, &curr->cast()->left); + break; + } + case Expression::Id::TryId: { + self->pushTask(SubType::doVisitTry, currp); + self->pushTask(SubType::scan, &curr->cast()->catchBody); + self->pushTask(SubType::scan, &curr->cast()->body); + break; + } + case Expression::Id::ThrowId: { + self->pushTask(SubType::doVisitThrow, currp); + auto& list = curr->cast()->operands; + for (int i = int(list.size()) - 1; i >= 0; i--) { + self->pushTask(SubType::scan, &list[i]); + } + break; + } + case Expression::Id::RethrowId: { + self->pushTask(SubType::doVisitRethrow, currp); + self->pushTask(SubType::scan, &curr->cast()->exnref); + break; + } + case Expression::Id::BrOnExnId: { + self->pushTask(SubType::doVisitBrOnExn, currp); + self->pushTask(SubType::scan, &curr->cast()->exnref); + break; + } + case Expression::Id::NopId: { + self->pushTask(SubType::doVisitNop, currp); + break; + } + case Expression::Id::UnreachableId: { + self->pushTask(SubType::doVisitUnreachable, currp); + break; + } + case Expression::Id::PopId: { + self->pushTask(SubType::doVisitPop, currp); + break; + } + case Expression::Id::TupleMakeId: { + self->pushTask(SubType::doVisitTupleMake, currp); + auto& operands = curr->cast()->operands; + for (int i = int(operands.size()) - 1; i >= 0; --i) { + self->pushTask(SubType::scan, &operands[i]); + } + break; + } + case Expression::Id::TupleExtractId: { + self->pushTask(SubType::doVisitTupleExtract, currp); + self->pushTask(SubType::scan, &curr->cast()->tuple); + break; + } + case Expression::Id::I31NewId: { + self->pushTask(SubType::doVisitI31New, currp); + self->pushTask(SubType::scan, &curr->cast()->value); + break; + } + case Expression::Id::I31GetId: { + self->pushTask(SubType::doVisitI31Get, currp); + self->pushTask(SubType::scan, &curr->cast()->i31); + break; + } + case Expression::Id::RefTestId: + self->pushTask(SubType::doVisitRefTest, currp); + WASM_UNREACHABLE("TODO (gc): ref.test"); + break; + case Expression::Id::RefCastId: + self->pushTask(SubType::doVisitRefCast, currp); + WASM_UNREACHABLE("TODO (gc): ref.cast"); + break; + case Expression::Id::BrOnCastId: + self->pushTask(SubType::doVisitBrOnCast, currp); + WASM_UNREACHABLE("TODO (gc): br_on_cast"); + break; + case Expression::Id::RttCanonId: + self->pushTask(SubType::doVisitRttCanon, currp); + WASM_UNREACHABLE("TODO (gc): rtt.canon"); + break; + case Expression::Id::RttSubId: + self->pushTask(SubType::doVisitRttSub, currp); + WASM_UNREACHABLE("TODO (gc): rtt.sub"); + break; + case Expression::Id::StructNewId: + self->pushTask(SubType::doVisitStructNew, currp); + WASM_UNREACHABLE("TODO (gc): struct.new"); + break; + case Expression::Id::StructGetId: + self->pushTask(SubType::doVisitStructGet, currp); + WASM_UNREACHABLE("TODO (gc): struct.get"); + break; + case Expression::Id::StructSetId: + self->pushTask(SubType::doVisitStructSet, currp); + WASM_UNREACHABLE("TODO (gc): struct.set"); + break; + case Expression::Id::ArrayNewId: + self->pushTask(SubType::doVisitArrayNew, currp); + WASM_UNREACHABLE("TODO (gc): array.new"); + break; + case Expression::Id::ArrayGetId: + self->pushTask(SubType::doVisitArrayGet, currp); + WASM_UNREACHABLE("TODO (gc): array.get"); + break; + case Expression::Id::ArraySetId: + self->pushTask(SubType::doVisitArraySet, currp); + WASM_UNREACHABLE("TODO (gc): array.set"); + break; + case Expression::Id::ArrayLenId: + self->pushTask(SubType::doVisitArrayLen, currp); + WASM_UNREACHABLE("TODO (gc): array.len"); + break; + case Expression::Id::NumExpressionIds: + WASM_UNREACHABLE("unexpected expression type"); + } + } +}; + +// Stacks of expressions tend to be limited in size (although, sometimes +// super-nested blocks exist for br_table). +typedef SmallVector ExpressionStack; + +// Traversal with a control-flow stack. + +template> +struct ControlFlowWalker : public PostWalker { + ControlFlowWalker() = default; + + ExpressionStack controlFlowStack; // contains blocks, loops, and ifs + + // Uses the control flow stack to find the target of a break to a name + Expression* findBreakTarget(Name name) { + assert(!controlFlowStack.empty()); + Index i = controlFlowStack.size() - 1; + while (true) { + auto* curr = controlFlowStack[i]; + if (Block* block = curr->template dynCast()) { + if (name == block->name) { + return curr; + } + } else if (Loop* loop = curr->template dynCast()) { + if (name == loop->name) { + return curr; + } + } else { + // an if or try, ignorable + assert(curr->template is() || curr->template is()); + } + if (i == 0) { + return nullptr; + } + i--; + } + } + + static void doPreVisitControlFlow(SubType* self, Expression** currp) { + self->controlFlowStack.push_back(*currp); + } + + static void doPostVisitControlFlow(SubType* self, Expression** currp) { + // note that we might be popping something else, as we may have been + // replaced + self->controlFlowStack.pop_back(); + } + + static void scan(SubType* self, Expression** currp) { + auto* curr = *currp; + + switch (curr->_id) { + case Expression::Id::BlockId: + case Expression::Id::IfId: + case Expression::Id::LoopId: + case Expression::Id::TryId: { + self->pushTask(SubType::doPostVisitControlFlow, currp); + break; + } + default: { + } + } + + PostWalker::scan(self, currp); + + switch (curr->_id) { + case Expression::Id::BlockId: + case Expression::Id::IfId: + case Expression::Id::LoopId: + case Expression::Id::TryId: { + self->pushTask(SubType::doPreVisitControlFlow, currp); + break; + } + default: { + } + } + } +}; + +// Traversal with an expression stack. + +template> +struct ExpressionStackWalker : public PostWalker { + ExpressionStackWalker() = default; + + ExpressionStack expressionStack; + + // Uses the control flow stack to find the target of a break to a name + Expression* findBreakTarget(Name name) { + assert(!expressionStack.empty()); + Index i = expressionStack.size() - 1; + while (true) { + auto* curr = expressionStack[i]; + if (Block* block = curr->template dynCast()) { + if (name == block->name) { + return curr; + } + } else if (Loop* loop = curr->template dynCast()) { + if (name == loop->name) { + return curr; + } + } + if (i == 0) { + return nullptr; + } + i--; + } + } + + Expression* getParent() { + if (expressionStack.size() == 1) { + return nullptr; + } + assert(expressionStack.size() >= 2); + return expressionStack[expressionStack.size() - 2]; + } + + static void doPreVisit(SubType* self, Expression** currp) { + self->expressionStack.push_back(*currp); + } + + static void doPostVisit(SubType* self, Expression** currp) { + self->expressionStack.pop_back(); + } + + static void scan(SubType* self, Expression** currp) { + self->pushTask(SubType::doPostVisit, currp); + + PostWalker::scan(self, currp); + + self->pushTask(SubType::doPreVisit, currp); + } + + Expression* replaceCurrent(Expression* expression) { + PostWalker::replaceCurrent(expression); + // also update the stack + expressionStack.back() = expression; + return expression; + } +}; + +// Traversal in the order of execution. This is quick and simple, but +// does not provide the same comprehensive information that a full +// conversion to basic blocks would. What it does give is a quick +// way to view straightline execution traces, i.e., that have no +// branching. This can let optimizations get most of what they +// want without the cost of creating another AST. +// +// When execution is no longer linear, this notifies via a call +// to noteNonLinear(). + +template> +struct LinearExecutionWalker : public PostWalker { + LinearExecutionWalker() = default; + + // subclasses should implement this + void noteNonLinear(Expression* curr) { abort(); } + + static void doNoteNonLinear(SubType* self, Expression** currp) { + self->noteNonLinear(*currp); + } + + static void scan(SubType* self, Expression** currp) { + + Expression* curr = *currp; + + switch (curr->_id) { + case Expression::Id::InvalidId: + abort(); + case Expression::Id::BlockId: { + self->pushTask(SubType::doVisitBlock, currp); + if (curr->cast()->name.is()) { + self->pushTask(SubType::doNoteNonLinear, currp); + } + auto& list = curr->cast()->list; + for (int i = int(list.size()) - 1; i >= 0; i--) { + self->pushTask(SubType::scan, &list[i]); + } + break; + } + case Expression::Id::IfId: { + self->pushTask(SubType::doVisitIf, currp); + self->pushTask(SubType::doNoteNonLinear, currp); + self->maybePushTask(SubType::scan, &curr->cast()->ifFalse); + self->pushTask(SubType::doNoteNonLinear, currp); + self->pushTask(SubType::scan, &curr->cast()->ifTrue); + self->pushTask(SubType::doNoteNonLinear, currp); + self->pushTask(SubType::scan, &curr->cast()->condition); + break; + } + case Expression::Id::LoopId: { + self->pushTask(SubType::doVisitLoop, currp); + self->pushTask(SubType::scan, &curr->cast()->body); + self->pushTask(SubType::doNoteNonLinear, currp); + break; + } + case Expression::Id::BreakId: { + self->pushTask(SubType::doVisitBreak, currp); + self->pushTask(SubType::doNoteNonLinear, currp); + self->maybePushTask(SubType::scan, &curr->cast()->condition); + self->maybePushTask(SubType::scan, &curr->cast()->value); + break; + } + case Expression::Id::SwitchId: { + self->pushTask(SubType::doVisitSwitch, currp); + self->pushTask(SubType::doNoteNonLinear, currp); + self->maybePushTask(SubType::scan, &curr->cast()->value); + self->pushTask(SubType::scan, &curr->cast()->condition); + break; + } + case Expression::Id::ReturnId: { + self->pushTask(SubType::doVisitReturn, currp); + self->pushTask(SubType::doNoteNonLinear, currp); + self->maybePushTask(SubType::scan, &curr->cast()->value); + break; + } + case Expression::Id::TryId: { + self->pushTask(SubType::doVisitTry, currp); + self->pushTask(SubType::doNoteNonLinear, currp); + self->pushTask(SubType::scan, &curr->cast()->catchBody); + self->pushTask(SubType::doNoteNonLinear, currp); + self->pushTask(SubType::scan, &curr->cast()->body); + break; + } + case Expression::Id::ThrowId: { + self->pushTask(SubType::doVisitThrow, currp); + self->pushTask(SubType::doNoteNonLinear, currp); + auto& list = curr->cast()->operands; + for (int i = int(list.size()) - 1; i >= 0; i--) { + self->pushTask(SubType::scan, &list[i]); + } + break; + } + case Expression::Id::RethrowId: { + self->pushTask(SubType::doVisitRethrow, currp); + self->pushTask(SubType::doNoteNonLinear, currp); + self->pushTask(SubType::scan, &curr->cast()->exnref); + break; + } + case Expression::Id::BrOnExnId: { + self->pushTask(SubType::doVisitBrOnExn, currp); + self->pushTask(SubType::doNoteNonLinear, currp); + self->pushTask(SubType::scan, &curr->cast()->exnref); + break; + } + case Expression::Id::UnreachableId: { + self->pushTask(SubType::doVisitUnreachable, currp); + self->pushTask(SubType::doNoteNonLinear, currp); + break; + } + default: { + // other node types do not have control flow, use regular post-order + PostWalker::scan(self, currp); + } + } + } +}; + +} // namespace wasm + +#endif // wasm_wasm_traversal_h diff --git a/binaryen/src/wasm-type.h b/binaryen/src/wasm-type.h new file mode 100644 --- /dev/null +++ b/binaryen/src/wasm-type.h @@ -0,0 +1,449 @@ +/* + * Copyright 2017 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef wasm_wasm_type_h +#define wasm_wasm_type_h + +#include "wasm-features.h" +#include +#include + +// TODO: At various code locations we were assuming that single types are basic +// types, but this is going to change with the introduction of the compound +// Signature, Struct and Array types that will be single but not basic. To +// prepare for this change, the following macro marks affected code locations. +#define TODO_SINGLE_COMPOUND(type) \ + assert(!type.isTuple() && "Unexpected tuple type"); \ + assert(!type.isCompound() && "TODO: handle compound types"); + +namespace wasm { + +class Type { + // The `id` uniquely represents each type, so type equality is just a + // comparison of the ids. For basic types the `id` is just the `BasicID` + // enum value below, and for constructed types the `id` is the address of the + // canonical representation of the type, making lookups cheap for all types. + uintptr_t id; + +public: + enum BasicID : uint32_t { + none, + unreachable, + i32, + i64, + f32, + f64, + v128, + funcref, + externref, + exnref, + anyref, + eqref, + i31ref, + _last_basic_id = i31ref, + }; + + Type() = default; + + // BasicID can be implicitly upgraded to Type + constexpr Type(BasicID id) : id(id){}; + + // But converting raw uint32_t is more dangerous, so make it explicit + explicit Type(uint64_t id) : id(id){}; + + // Construct tuple from a list of single types + Type(std::initializer_list); + + // Construct from tuple description + explicit Type(const struct Tuple&); + + // Construct from a heap type description. Also covers construction from + // Signature, Struct or Array via implicit conversion to HeapType. + explicit Type(const struct HeapType&, bool nullable); + + // Construct from rtt description + explicit Type(const struct Rtt&); + + // Predicates + // Compound Concrete + // Type Basic │ Single│ + // ╒═════════════╦═│═╤═│═╤═│═╤═│═╤═══════╕ + // │ none ║ x │ │ │ │ │ + // │ unreachable ║ x │ │ │ │ │ + // ├─────────────╫───┼───┼───┼───┤───────┤ + // │ i32 ║ x │ │ x │ x │ I │ ┐ Number + // │ i64 ║ x │ │ x │ x │ I │ │ I_nteger + // │ f32 ║ x │ │ x │ x │ F │ │ F_loat + // │ f64 ║ x │ │ x │ x │ F │ │ V_ector + // │ v128 ║ x │ │ x │ x │ V │ ┘ + // ├─ Aliases ───╫───┼───┼───┼───┤───────┤ + // │ funcref ║ x │ │ x │ x │ f n │ ┐ Ref + // │ externref ║ x │ │ x │ x │ f? n │ │ f_unc + // │ exnref ║ x │ │ x │ x │ n │ │ n_ullable + // │ anyref ║ x │ │ x │ x │ f? n │ │ + // │ eqref ║ x │ │ x │ x │ n │ │ ┐ TODO (GC) + // │ i31ref ║ x │ │ x │ x │ │ │ ┘ + // ├─ Compound ──╫───┼───┼───┼───┤───────┤ │ + // │ Ref ║ │ x │ x │ x │ f? n? │◄┘ + // │ Tuple ║ │ x │ │ x │ │ + // │ Rtt ║ │ x │ x │ x │ │ + // └─────────────╨───┴───┴───┴───┴───────┘ + constexpr bool isBasic() const { return id <= _last_basic_id; } + constexpr bool isCompound() const { return id > _last_basic_id; } + constexpr bool isConcrete() const { return id >= i32; } + constexpr bool isInteger() const { return id == i32 || id == i64; } + constexpr bool isFloat() const { return id == f32 || id == f64; } + constexpr bool isVector() const { return id == v128; }; + constexpr bool isNumber() const { return id >= i32 && id <= v128; } + bool isTuple() const; + bool isSingle() const { return isConcrete() && !isTuple(); } + bool isRef() const; + bool isFunction() const; + bool isException() const; + bool isNullable() const; + bool isRtt() const; + +private: + template bool hasPredicate() { + for (const auto& type : *this) { + if ((type.*pred)()) { + return true; + } + } + return false; + } + +public: + bool hasVector() { return hasPredicate<&Type::isVector>(); } + bool hasRef() { return hasPredicate<&Type::isRef>(); } + + constexpr uint64_t getID() const { return id; } + constexpr BasicID getBasic() const { + assert(isBasic() && "Basic type expected"); + return static_cast(id); + } + + // (In)equality must be defined for both Type and BasicID because it is + // otherwise ambiguous whether to convert both this and other to int or + // convert other to Type. + bool operator==(const Type& other) const { return id == other.id; } + bool operator==(const BasicID& otherId) const { return id == otherId; } + bool operator!=(const Type& other) const { return id != other.id; } + bool operator!=(const BasicID& otherId) const { return id != otherId; } + + // Order types by some notion of simplicity + bool operator<(const Type& other) const; + + // Returns the type size in bytes. Only single types are supported. + unsigned getByteSize() const; + + // Reinterpret an integer type to a float type with the same size and vice + // versa. Only single integer and float types are supported. + Type reinterpret() const; + + // Returns the feature set required to use this type. + FeatureSet getFeatures() const; + + // Gets the heap type corresponding to this type + HeapType getHeapType() const; + + // Returns a number type based on its size in bytes and whether it is a float + // type. + static Type get(unsigned byteSize, bool float_); + + // Returns true if left is a subtype of right. Subtype includes itself. + static bool isSubType(Type left, Type right); + + // Computes the least upper bound from the type lattice. + // If one of the type is unreachable, the other type becomes the result. If + // the common supertype does not exist, returns none, a poison value. + static Type getLeastUpperBound(Type a, Type b); + + // Computes the least upper bound for all types in the given list. + template static Type mergeTypes(const T& types) { + Type type = Type::unreachable; + for (auto other : types) { + type = Type::getLeastUpperBound(type, other); + } + return type; + } + + std::string toString() const; + + struct Iterator + : std::iterator { + const Type* parent; + size_t index; + Iterator(const Type* parent, size_t index) : parent(parent), index(index) {} + bool operator==(const Iterator& other) const { + return index == other.index && parent == other.parent; + } + bool operator!=(const Iterator& other) const { return !(*this == other); } + Iterator& operator++() { + ++index; + return *this; + } + Iterator& operator--() { + --index; + return *this; + } + Iterator operator++(int) { + auto it = *this; + index++; + return it; + } + Iterator operator--(int) { + auto it = *this; + index--; + return it; + } + Iterator& operator+=(difference_type off) { + index += off; + return *this; + } + Iterator operator+(difference_type off) const { + return Iterator(*this) += off; + } + Iterator& operator-=(difference_type off) { + index -= off; + return *this; + } + Iterator operator-(difference_type off) const { + return Iterator(*this) -= off; + } + difference_type operator-(const Iterator& other) const { + assert(parent == other.parent); + return index - other.index; + } + const value_type& operator*() const; + }; + + Iterator begin() const { return Iterator(this, 0); } + Iterator end() const; + size_t size() const { return end() - begin(); } + const Type& operator[](size_t i) const; +}; + +// Wrapper type for formatting types as "(param i32 i64 f32)" +struct ParamType { + Type type; + ParamType(Type type) : type(type) {} + std::string toString() const; +}; + +// Wrapper type for formatting types as "(result i32 i64 f32)" +struct ResultType { + Type type; + ResultType(Type type) : type(type) {} + std::string toString() const; +}; + +typedef std::vector TypeList; + +struct Tuple { + TypeList types; + Tuple() : types() {} + Tuple(std::initializer_list types) : types(types) {} + Tuple(const TypeList& types) : types(types) {} + Tuple(TypeList&& types) : types(std::move(types)) {} + bool operator==(const Tuple& other) const { return types == other.types; } + bool operator!=(const Tuple& other) const { return !(*this == other); } + std::string toString() const; +}; + +struct Signature { + Type params; + Type results; + Signature() : params(Type::none), results(Type::none) {} + Signature(Type params, Type results) : params(params), results(results) {} + bool operator==(const Signature& other) const { + return params == other.params && results == other.results; + } + bool operator!=(const Signature& other) const { return !(*this == other); } + bool operator<(const Signature& other) const; + std::string toString() const; +}; + +struct Field { + Type type; + enum PackedType { + not_packed, + i8, + i16, + } packedType; // applicable iff type=i32 + bool mutable_; + + Field(Type type, bool mutable_ = false) + : type(type), packedType(not_packed), mutable_(mutable_) {} + Field(PackedType packedType, bool mutable_ = false) + : type(Type::i32), packedType(packedType), mutable_(mutable_) {} + + constexpr bool isPacked() const { + if (packedType != not_packed) { + assert(type == Type::i32 && "unexpected type"); + return true; + } + return false; + } + + bool operator==(const Field& other) const { + return type == other.type && packedType == other.packedType && + mutable_ == other.mutable_; + } + bool operator!=(const Field& other) const { return !(*this == other); } + std::string toString() const; +}; + +typedef std::vector FieldList; + +struct Struct { + FieldList fields; + Struct(const Struct& other) : fields(other.fields) {} + Struct(const FieldList& fields) : fields(fields) {} + Struct(FieldList&& fields) : fields(std::move(fields)) {} + bool operator==(const Struct& other) const { return fields == other.fields; } + bool operator!=(const Struct& other) const { return !(*this == other); } + std::string toString() const; +}; + +struct Array { + Field element; + Array(const Array& other) : element(other.element) {} + Array(const Field& element) : element(element) {} + Array(Field&& element) : element(std::move(element)) {} + bool operator==(const Array& other) const { return element == other.element; } + bool operator!=(const Array& other) const { return !(*this == other); } + std::string toString() const; +}; + +struct HeapType { + enum Kind { + FuncKind, + ExternKind, + ExnKind, + AnyKind, + EqKind, + I31Kind, + _last_basic_kind = I31Kind, + SignatureKind, + StructKind, + ArrayKind, + } kind; + union { + Signature signature; + Struct struct_; + Array array; + }; + HeapType(Kind kind) : kind(kind) { assert(kind <= _last_basic_kind); } + HeapType(const Signature& signature) + : kind(SignatureKind), signature(signature) {} + HeapType(Signature&& signature) + : kind(SignatureKind), signature(std::move(signature)) {} + HeapType(const Struct& struct_) : kind(StructKind), struct_(struct_) {} + HeapType(Struct&& struct_) : kind(StructKind), struct_(std::move(struct_)) {} + HeapType(const Array& array) : kind(ArrayKind), array(array) {} + HeapType(Array&& array) : kind(ArrayKind), array(std::move(array)) {} + HeapType(const HeapType& other); + ~HeapType(); + + bool isSignature() const { return kind == SignatureKind; } + Signature getSignature() const { + assert(isSignature() && "Not a signature"); + return signature; + } + bool isStruct() const { return kind == StructKind; } + Struct getStruct() const { + assert(isStruct() && "Not a struct"); + return struct_; + } + bool isArray() const { return kind == ArrayKind; } + Array getArray() const { + assert(isArray() && "Not an array"); + return array; + } + bool isException() const { return kind == ExnKind; } + + bool operator==(const HeapType& other) const; + bool operator!=(const HeapType& other) const { return !(*this == other); } + HeapType& operator=(const HeapType& other); + std::string toString() const; +}; + +struct Rtt { + uint32_t depth; + HeapType heapType; + Rtt(uint32_t depth, const HeapType& heapType) + : depth(depth), heapType(heapType) {} + Rtt(uint32_t depth, HeapType&& heapType) + : depth(depth), heapType(std::move(heapType)) {} + bool operator==(const Rtt& other) const { + return depth == other.depth && heapType == other.heapType; + } + bool operator!=(const Rtt& other) const { return !(*this == other); } + std::string toString() const; +}; + +std::ostream& operator<<(std::ostream&, Type); +std::ostream& operator<<(std::ostream&, ParamType); +std::ostream& operator<<(std::ostream&, ResultType); +std::ostream& operator<<(std::ostream&, Tuple); +std::ostream& operator<<(std::ostream&, Signature); +std::ostream& operator<<(std::ostream&, Field); +std::ostream& operator<<(std::ostream&, Struct); +std::ostream& operator<<(std::ostream&, Array); +std::ostream& operator<<(std::ostream&, HeapType); +std::ostream& operator<<(std::ostream&, Rtt); + +} // namespace wasm + +namespace std { + +template<> class hash { +public: + size_t operator()(const wasm::Type&) const; +}; +template<> class hash { +public: + size_t operator()(const wasm::Tuple&) const; +}; +template<> class hash { +public: + size_t operator()(const wasm::Signature&) const; +}; +template<> class hash { +public: + size_t operator()(const wasm::Field&) const; +}; +template<> class hash { +public: + size_t operator()(const wasm::Struct&) const; +}; +template<> class hash { +public: + size_t operator()(const wasm::Array&) const; +}; +template<> class hash { +public: + size_t operator()(const wasm::HeapType&) const; +}; +template<> class hash { +public: + size_t operator()(const wasm::Rtt&) const; +}; + +} // namespace std + +#endif // wasm_wasm_type_h diff --git a/binaryen/src/wasm-validator.h b/binaryen/src/wasm-validator.h new file mode 100644 --- /dev/null +++ b/binaryen/src/wasm-validator.h @@ -0,0 +1,65 @@ +/* + * Copyright 2015 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// Simple WebAssembly module validator. +// +// There are some options regarding how to validate: +// +// * validateWeb: The Web platform doesn't have i64 values, so it is illegal +// to import or export such a value. When this option is set, +// such imports/exports are validation errors. +// +// * validateGlobally: Binaryen supports building modules in parallel, which +// means you can add and optimize a function before the +// module is complete, for example, you can add function A +// with a call to function B before function B exists. +// When validateGlobally is disabled, we don't look at +// global correctness, and instead only check inside +// each function (so in the example above we wouldn't care +// about function B not existing yet, but we would care +// if e.g. inside function A an i32.add receives an i64). +// +// * quiet: Whether to log errors verbosely. +// + +#ifndef wasm_wasm_validator_h +#define wasm_wasm_validator_h + +#include +#include +#include + +#include "wasm-printing.h" +#include "wasm.h" + +namespace wasm { + +struct WasmValidator { + enum FlagValues { + Minimal = 0, + Web = 1 << 0, + Globally = 1 << 1, + Quiet = 1 << 2 + }; + typedef uint32_t Flags; + + bool validate(Module& module, Flags flags = Globally); +}; + +} // namespace wasm + +#endif // wasm_wasm_validator_h diff --git a/binaryen/src/wasm.h b/binaryen/src/wasm.h new file mode 100644 --- /dev/null +++ b/binaryen/src/wasm.h @@ -0,0 +1,1721 @@ +/* + * Copyright 2015 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// wasm.h: Define Binaryen IR, a representation for WebAssembly, with +// all core parts in one simple header file. +// +// For more overview, see README.md +// + +#ifndef wasm_wasm_h +#define wasm_wasm_h + +#include +#include +#include +#include +#include +#include + +#include "literal.h" +#include "mixed_arena.h" +#include "support/name.h" +#include "wasm-features.h" +#include "wasm-type.h" + +namespace wasm { + +// An index in a wasm module +typedef uint32_t Index; + +// An address in linear memory. +struct Address { + typedef uint32_t address32_t; + typedef uint64_t address64_t; + address64_t addr; + Address() : addr(0) {} + Address(uint64_t a) : addr(a) {} + Address& operator=(uint64_t a) { + addr = a; + return *this; + } + operator address64_t() const { return addr; } + Address& operator++() { + ++addr; + return *this; + } +}; + +enum class IRProfile { Normal, Poppy }; + +// Operators + +enum UnaryOp { + // int + ClzInt32, + ClzInt64, + CtzInt32, + CtzInt64, + PopcntInt32, + PopcntInt64, + + // float + NegFloat32, + NegFloat64, + AbsFloat32, + AbsFloat64, + CeilFloat32, + CeilFloat64, + FloorFloat32, + FloorFloat64, + TruncFloat32, + TruncFloat64, + NearestFloat32, + NearestFloat64, + SqrtFloat32, + SqrtFloat64, + + // relational + EqZInt32, + EqZInt64, + + // conversions + // extend i32 to i64 + ExtendSInt32, + ExtendUInt32, + // i64 to i32 + WrapInt64, + // float to int + TruncSFloat32ToInt32, + TruncSFloat32ToInt64, + TruncUFloat32ToInt32, + TruncUFloat32ToInt64, + TruncSFloat64ToInt32, + TruncSFloat64ToInt64, + TruncUFloat64ToInt32, + TruncUFloat64ToInt64, + // reintepret bits to int + ReinterpretFloat32, + ReinterpretFloat64, + // int to float + ConvertSInt32ToFloat32, + ConvertSInt32ToFloat64, + ConvertUInt32ToFloat32, + ConvertUInt32ToFloat64, + ConvertSInt64ToFloat32, + ConvertSInt64ToFloat64, + ConvertUInt64ToFloat32, + ConvertUInt64ToFloat64, + // f32 to f64 + PromoteFloat32, + // f64 to f32 + DemoteFloat64, + // reinterpret bits to float + ReinterpretInt32, + ReinterpretInt64, + + // Extend signed subword-sized integer. This differs from e.g. ExtendSInt32 + // because the input integer is in an i64 value insetad of an i32 value. + ExtendS8Int32, + ExtendS16Int32, + ExtendS8Int64, + ExtendS16Int64, + ExtendS32Int64, + + // Saturating float-to-int + TruncSatSFloat32ToInt32, + TruncSatUFloat32ToInt32, + TruncSatSFloat64ToInt32, + TruncSatUFloat64ToInt32, + TruncSatSFloat32ToInt64, + TruncSatUFloat32ToInt64, + TruncSatSFloat64ToInt64, + TruncSatUFloat64ToInt64, + + // SIMD splats + SplatVecI8x16, + SplatVecI16x8, + SplatVecI32x4, + SplatVecI64x2, + SplatVecF32x4, + SplatVecF64x2, + + // SIMD arithmetic + NotVec128, + AbsVecI8x16, + NegVecI8x16, + AnyTrueVecI8x16, + AllTrueVecI8x16, + BitmaskVecI8x16, + AbsVecI16x8, + NegVecI16x8, + AnyTrueVecI16x8, + AllTrueVecI16x8, + BitmaskVecI16x8, + AbsVecI32x4, + NegVecI32x4, + AnyTrueVecI32x4, + AllTrueVecI32x4, + BitmaskVecI32x4, + NegVecI64x2, + AnyTrueVecI64x2, + AllTrueVecI64x2, + AbsVecF32x4, + NegVecF32x4, + SqrtVecF32x4, + CeilVecF32x4, + FloorVecF32x4, + TruncVecF32x4, + NearestVecF32x4, + AbsVecF64x2, + NegVecF64x2, + SqrtVecF64x2, + CeilVecF64x2, + FloorVecF64x2, + TruncVecF64x2, + NearestVecF64x2, + + // SIMD conversions + TruncSatSVecF32x4ToVecI32x4, + TruncSatUVecF32x4ToVecI32x4, + TruncSatSVecF64x2ToVecI64x2, + TruncSatUVecF64x2ToVecI64x2, + ConvertSVecI32x4ToVecF32x4, + ConvertUVecI32x4ToVecF32x4, + ConvertSVecI64x2ToVecF64x2, + ConvertUVecI64x2ToVecF64x2, + WidenLowSVecI8x16ToVecI16x8, + WidenHighSVecI8x16ToVecI16x8, + WidenLowUVecI8x16ToVecI16x8, + WidenHighUVecI8x16ToVecI16x8, + WidenLowSVecI16x8ToVecI32x4, + WidenHighSVecI16x8ToVecI32x4, + WidenLowUVecI16x8ToVecI32x4, + WidenHighUVecI16x8ToVecI32x4, + + InvalidUnary +}; + +enum BinaryOp { + // int or float + AddInt32, + SubInt32, + MulInt32, + + // int + DivSInt32, + DivUInt32, + RemSInt32, + RemUInt32, + AndInt32, + OrInt32, + XorInt32, + ShlInt32, + ShrSInt32, + ShrUInt32, + RotLInt32, + RotRInt32, + + // relational ops + // int or float + EqInt32, + NeInt32, + // int + LtSInt32, + LtUInt32, + LeSInt32, + LeUInt32, + GtSInt32, + GtUInt32, + GeSInt32, + GeUInt32, + + // int or float + AddInt64, + SubInt64, + MulInt64, + + // int + DivSInt64, + DivUInt64, + RemSInt64, + RemUInt64, + AndInt64, + OrInt64, + XorInt64, + ShlInt64, + ShrSInt64, + ShrUInt64, + RotLInt64, + RotRInt64, + + // relational ops + // int or float + EqInt64, + NeInt64, + // int + LtSInt64, + LtUInt64, + LeSInt64, + LeUInt64, + GtSInt64, + GtUInt64, + GeSInt64, + GeUInt64, + + // int or float + AddFloat32, + SubFloat32, + MulFloat32, + + // float + DivFloat32, + CopySignFloat32, + MinFloat32, + MaxFloat32, + + // relational ops + // int or float + EqFloat32, + NeFloat32, + // float + LtFloat32, + LeFloat32, + GtFloat32, + GeFloat32, + + // int or float + AddFloat64, + SubFloat64, + MulFloat64, + + // float + DivFloat64, + CopySignFloat64, + MinFloat64, + MaxFloat64, + + // relational ops + // int or float + EqFloat64, + NeFloat64, + // float + LtFloat64, + LeFloat64, + GtFloat64, + GeFloat64, + + // SIMD relational ops (return vectors) + EqVecI8x16, + NeVecI8x16, + LtSVecI8x16, + LtUVecI8x16, + GtSVecI8x16, + GtUVecI8x16, + LeSVecI8x16, + LeUVecI8x16, + GeSVecI8x16, + GeUVecI8x16, + EqVecI16x8, + NeVecI16x8, + LtSVecI16x8, + LtUVecI16x8, + GtSVecI16x8, + GtUVecI16x8, + LeSVecI16x8, + LeUVecI16x8, + GeSVecI16x8, + GeUVecI16x8, + EqVecI32x4, + NeVecI32x4, + LtSVecI32x4, + LtUVecI32x4, + GtSVecI32x4, + GtUVecI32x4, + LeSVecI32x4, + LeUVecI32x4, + GeSVecI32x4, + GeUVecI32x4, + EqVecF32x4, + NeVecF32x4, + LtVecF32x4, + GtVecF32x4, + LeVecF32x4, + GeVecF32x4, + EqVecF64x2, + NeVecF64x2, + LtVecF64x2, + GtVecF64x2, + LeVecF64x2, + GeVecF64x2, + + // SIMD arithmetic + AndVec128, + OrVec128, + XorVec128, + AndNotVec128, + AddVecI8x16, + AddSatSVecI8x16, + AddSatUVecI8x16, + SubVecI8x16, + SubSatSVecI8x16, + SubSatUVecI8x16, + MulVecI8x16, + MinSVecI8x16, + MinUVecI8x16, + MaxSVecI8x16, + MaxUVecI8x16, + AvgrUVecI8x16, + AddVecI16x8, + AddSatSVecI16x8, + AddSatUVecI16x8, + SubVecI16x8, + SubSatSVecI16x8, + SubSatUVecI16x8, + MulVecI16x8, + MinSVecI16x8, + MinUVecI16x8, + MaxSVecI16x8, + MaxUVecI16x8, + AvgrUVecI16x8, + AddVecI32x4, + SubVecI32x4, + MulVecI32x4, + MinSVecI32x4, + MinUVecI32x4, + MaxSVecI32x4, + MaxUVecI32x4, + DotSVecI16x8ToVecI32x4, + AddVecI64x2, + SubVecI64x2, + MulVecI64x2, + AddVecF32x4, + SubVecF32x4, + MulVecF32x4, + DivVecF32x4, + MinVecF32x4, + MaxVecF32x4, + PMinVecF32x4, + PMaxVecF32x4, + AddVecF64x2, + SubVecF64x2, + MulVecF64x2, + DivVecF64x2, + MinVecF64x2, + MaxVecF64x2, + PMinVecF64x2, + PMaxVecF64x2, + + // SIMD Conversion + NarrowSVecI16x8ToVecI8x16, + NarrowUVecI16x8ToVecI8x16, + NarrowSVecI32x4ToVecI16x8, + NarrowUVecI32x4ToVecI16x8, + + // SIMD Swizzle + SwizzleVec8x16, + + InvalidBinary +}; + +enum AtomicRMWOp { Add, Sub, And, Or, Xor, Xchg }; + +enum SIMDExtractOp { + ExtractLaneSVecI8x16, + ExtractLaneUVecI8x16, + ExtractLaneSVecI16x8, + ExtractLaneUVecI16x8, + ExtractLaneVecI32x4, + ExtractLaneVecI64x2, + ExtractLaneVecF32x4, + ExtractLaneVecF64x2 +}; + +enum SIMDReplaceOp { + ReplaceLaneVecI8x16, + ReplaceLaneVecI16x8, + ReplaceLaneVecI32x4, + ReplaceLaneVecI64x2, + ReplaceLaneVecF32x4, + ReplaceLaneVecF64x2 +}; + +enum SIMDShiftOp { + ShlVecI8x16, + ShrSVecI8x16, + ShrUVecI8x16, + ShlVecI16x8, + ShrSVecI16x8, + ShrUVecI16x8, + ShlVecI32x4, + ShrSVecI32x4, + ShrUVecI32x4, + ShlVecI64x2, + ShrSVecI64x2, + ShrUVecI64x2 +}; + +enum SIMDLoadOp { + LoadSplatVec8x16, + LoadSplatVec16x8, + LoadSplatVec32x4, + LoadSplatVec64x2, + LoadExtSVec8x8ToVecI16x8, + LoadExtUVec8x8ToVecI16x8, + LoadExtSVec16x4ToVecI32x4, + LoadExtUVec16x4ToVecI32x4, + LoadExtSVec32x2ToVecI64x2, + LoadExtUVec32x2ToVecI64x2, + Load32Zero, + Load64Zero +}; + +enum SIMDTernaryOp { Bitselect, QFMAF32x4, QFMSF32x4, QFMAF64x2, QFMSF64x2 }; + +// +// Expressions +// +// Note that little is provided in terms of constructors for these. The +// rationale is that writing new Something(a, b, c, d, e) is not the clearest, +// and it would be better to write new Something(name=a, leftOperand=b... +// etc., but C++ lacks named operands, so in asm2wasm etc. you will see things +// like +// auto x = new Something(); +// x->name = a; +// x->leftOperand = b; +// .. +// which is less compact but less ambiguous. See wasm-builder.h for a more +// friendly API for building nodes. +// +// Most nodes have no need of internal allocation, and when arena-allocated +// they drop the provided arena on the floor. You can create random instances +// of those that are not in an arena without issue. However, the nodes that +// have internal allocation will need an allocator provided to them in order +// to be constructed. + +class Expression { +public: + enum Id { + InvalidId = 0, + BlockId, + IfId, + LoopId, + BreakId, + SwitchId, + CallId, + CallIndirectId, + LocalGetId, + LocalSetId, + GlobalGetId, + GlobalSetId, + LoadId, + StoreId, + ConstId, + UnaryId, + BinaryId, + SelectId, + DropId, + ReturnId, + MemorySizeId, + MemoryGrowId, + NopId, + UnreachableId, + AtomicRMWId, + AtomicCmpxchgId, + AtomicWaitId, + AtomicNotifyId, + AtomicFenceId, + SIMDExtractId, + SIMDReplaceId, + SIMDShuffleId, + SIMDTernaryId, + SIMDShiftId, + SIMDLoadId, + MemoryInitId, + DataDropId, + MemoryCopyId, + MemoryFillId, + PopId, + RefNullId, + RefIsNullId, + RefFuncId, + RefEqId, + TryId, + ThrowId, + RethrowId, + BrOnExnId, + TupleMakeId, + TupleExtractId, + I31NewId, + I31GetId, + RefTestId, + RefCastId, + BrOnCastId, + RttCanonId, + RttSubId, + StructNewId, + StructGetId, + StructSetId, + ArrayNewId, + ArrayGetId, + ArraySetId, + ArrayLenId, + NumExpressionIds + }; + Id _id; + + // the type of the expression: its *output*, not necessarily its input(s) + Type type = Type::none; + + Expression(Id id) : _id(id) {} + + void finalize() {} + + template bool is() const { + static_assert(std::is_base_of::value, + "Expression is not a base of destination type T"); + return int(_id) == int(T::SpecificId); + } + + template T* dynCast() { + static_assert(std::is_base_of::value, + "Expression is not a base of destination type T"); + return int(_id) == int(T::SpecificId) ? (T*)this : nullptr; + } + + template const T* dynCast() const { + static_assert(std::is_base_of::value, + "Expression is not a base of destination type T"); + return int(_id) == int(T::SpecificId) ? (const T*)this : nullptr; + } + + template T* cast() { + static_assert(std::is_base_of::value, + "Expression is not a base of destination type T"); + assert(int(_id) == int(T::SpecificId)); + return (T*)this; + } + + template const T* cast() const { + static_assert(std::is_base_of::value, + "Expression is not a base of destination type T"); + assert(int(_id) == int(T::SpecificId)); + return (const T*)this; + } + + // Print the expression to stderr. Meant for use while debugging. + void dump(); +}; + +const char* getExpressionName(Expression* curr); + +Literal getLiteralFromConstExpression(Expression* curr); +Literals getLiteralsFromConstExpression(Expression* curr); + +typedef ArenaVector ExpressionList; + +template class SpecificExpression : public Expression { +public: + enum { + SpecificId = SID // compile-time access to the type for the class + }; + + SpecificExpression() : Expression(SID) {} +}; + +class Nop : public SpecificExpression { +public: + Nop() = default; + Nop(MixedArena& allocator) {} +}; + +class Block : public SpecificExpression { +public: + Block(MixedArena& allocator) : list(allocator) {} + + Name name; + ExpressionList list; + + // set the type purely based on its contents. this scans the block, so it is + // not fast. + void finalize(); + + // set the type given you know its type, which is the case when parsing + // s-expression or binary, as explicit types are given. the only additional + // work this does is to set the type to unreachable in the cases that is + // needed (which may require scanning the block) + void finalize(Type type_); + + // set the type given you know its type, and you know if there is a break to + // this block. this avoids the need to scan the contents of the block in the + // case that it might be unreachable, so it is recommended if you already know + // the type and breakability anyhow. + void finalize(Type type_, bool hasBreak); +}; + +class If : public SpecificExpression { +public: + If() : ifFalse(nullptr) {} + If(MixedArena& allocator) : If() {} + + Expression* condition; + Expression* ifTrue; + Expression* ifFalse; + + // set the type given you know its type, which is the case when parsing + // s-expression or binary, as explicit types are given. the only additional + // work this does is to set the type to unreachable in the cases that is + // needed. + void finalize(Type type_); + + // set the type purely based on its contents. + void finalize(); +}; + +class Loop : public SpecificExpression { +public: + Loop() = default; + Loop(MixedArena& allocator) {} + + Name name; + Expression* body; + + // set the type given you know its type, which is the case when parsing + // s-expression or binary, as explicit types are given. the only additional + // work this does is to set the type to unreachable in the cases that is + // needed. + void finalize(Type type_); + + // set the type purely based on its contents. + void finalize(); +}; + +class Break : public SpecificExpression { +public: + Break() : value(nullptr), condition(nullptr) {} + Break(MixedArena& allocator) : Break() { type = Type::unreachable; } + + Name name; + Expression* value; + Expression* condition; + + void finalize(); +}; + +class Switch : public SpecificExpression { +public: + Switch(MixedArena& allocator) : targets(allocator) { + type = Type::unreachable; + } + + ArenaVector targets; + Name default_; + Expression* condition = nullptr; + Expression* value = nullptr; + + void finalize(); +}; + +class Call : public SpecificExpression { +public: + Call(MixedArena& allocator) : operands(allocator) {} + + ExpressionList operands; + Name target; + bool isReturn = false; + + void finalize(); +}; + +class CallIndirect : public SpecificExpression { +public: + CallIndirect(MixedArena& allocator) : operands(allocator) {} + Signature sig; + ExpressionList operands; + Expression* target; + bool isReturn = false; + + void finalize(); +}; + +class LocalGet : public SpecificExpression { +public: + LocalGet() = default; + LocalGet(MixedArena& allocator) {} + + Index index; +}; + +class LocalSet : public SpecificExpression { +public: + LocalSet() = default; + LocalSet(MixedArena& allocator) {} + + void finalize(); + + Index index; + Expression* value; + + bool isTee() const; + void makeTee(Type type); + void makeSet(); +}; + +class GlobalGet : public SpecificExpression { +public: + GlobalGet() = default; + GlobalGet(MixedArena& allocator) {} + + Name name; +}; + +class GlobalSet : public SpecificExpression { +public: + GlobalSet() = default; + GlobalSet(MixedArena& allocator) {} + + Name name; + Expression* value; + + void finalize(); +}; + +class Load : public SpecificExpression { +public: + Load() = default; + Load(MixedArena& allocator) {} + + uint8_t bytes; + bool signed_; + Address offset; + Address align; + bool isAtomic; + Expression* ptr; + + // type must be set during creation, cannot be inferred + + void finalize(); +}; + +class Store : public SpecificExpression { +public: + Store() = default; + Store(MixedArena& allocator) : Store() {} + + uint8_t bytes; + Address offset; + Address align; + bool isAtomic; + Expression* ptr; + Expression* value; + Type valueType; + + void finalize(); +}; + +class AtomicRMW : public SpecificExpression { +public: + AtomicRMW() = default; + AtomicRMW(MixedArena& allocator) : AtomicRMW() {} + + AtomicRMWOp op; + uint8_t bytes; + Address offset; + Expression* ptr; + Expression* value; + + void finalize(); +}; + +class AtomicCmpxchg : public SpecificExpression { +public: + AtomicCmpxchg() = default; + AtomicCmpxchg(MixedArena& allocator) : AtomicCmpxchg() {} + + uint8_t bytes; + Address offset; + Expression* ptr; + Expression* expected; + Expression* replacement; + + void finalize(); +}; + +class AtomicWait : public SpecificExpression { +public: + AtomicWait() = default; + AtomicWait(MixedArena& allocator) : AtomicWait() {} + + Address offset; + Expression* ptr; + Expression* expected; + Expression* timeout; + Type expectedType; + + void finalize(); +}; + +class AtomicNotify : public SpecificExpression { +public: + AtomicNotify() = default; + AtomicNotify(MixedArena& allocator) : AtomicNotify() {} + + Address offset; + Expression* ptr; + Expression* notifyCount; + + void finalize(); +}; + +class AtomicFence : public SpecificExpression { +public: + AtomicFence() = default; + AtomicFence(MixedArena& allocator) : AtomicFence() {} + + // Current wasm threads only supports sequentialy consistent atomics, but + // other orderings may be added in the future. This field is reserved for + // that, and currently set to 0. + uint8_t order = 0; + + void finalize(); +}; + +class SIMDExtract : public SpecificExpression { +public: + SIMDExtract() = default; + SIMDExtract(MixedArena& allocator) : SIMDExtract() {} + + SIMDExtractOp op; + Expression* vec; + uint8_t index; + + void finalize(); +}; + +class SIMDReplace : public SpecificExpression { +public: + SIMDReplace() = default; + SIMDReplace(MixedArena& allocator) : SIMDReplace() {} + + SIMDReplaceOp op; + Expression* vec; + uint8_t index; + Expression* value; + + void finalize(); +}; + +class SIMDShuffle : public SpecificExpression { +public: + SIMDShuffle() = default; + SIMDShuffle(MixedArena& allocator) : SIMDShuffle() {} + + Expression* left; + Expression* right; + std::array mask; + + void finalize(); +}; + +class SIMDTernary : public SpecificExpression { +public: + SIMDTernary() = default; + SIMDTernary(MixedArena& allocator) : SIMDTernary() {} + + SIMDTernaryOp op; + Expression* a; + Expression* b; + Expression* c; + + void finalize(); +}; + +class SIMDShift : public SpecificExpression { +public: + SIMDShift() = default; + SIMDShift(MixedArena& allocator) : SIMDShift() {} + + SIMDShiftOp op; + Expression* vec; + Expression* shift; + + void finalize(); +}; + +class SIMDLoad : public SpecificExpression { +public: + SIMDLoad() = default; + SIMDLoad(MixedArena& allocator) {} + + SIMDLoadOp op; + Address offset; + Address align; + Expression* ptr; + + Index getMemBytes(); + void finalize(); +}; + +class MemoryInit : public SpecificExpression { +public: + MemoryInit() = default; + MemoryInit(MixedArena& allocator) : MemoryInit() {} + + Index segment; + Expression* dest; + Expression* offset; + Expression* size; + + void finalize(); +}; + +class DataDrop : public SpecificExpression { +public: + DataDrop() = default; + DataDrop(MixedArena& allocator) : DataDrop() {} + + Index segment; + + void finalize(); +}; + +class MemoryCopy : public SpecificExpression { +public: + MemoryCopy() = default; + MemoryCopy(MixedArena& allocator) : MemoryCopy() {} + + Expression* dest; + Expression* source; + Expression* size; + + void finalize(); +}; + +class MemoryFill : public SpecificExpression { +public: + MemoryFill() = default; + MemoryFill(MixedArena& allocator) : MemoryFill() {} + + Expression* dest; + Expression* value; + Expression* size; + + void finalize(); +}; + +class Const : public SpecificExpression { +public: + Const() = default; + Const(MixedArena& allocator) {} + + Literal value; + + Const* set(Literal value_); + + void finalize(); +}; + +class Unary : public SpecificExpression { +public: + Unary() = default; + Unary(MixedArena& allocator) {} + + UnaryOp op; + Expression* value; + + bool isRelational(); + + void finalize(); +}; + +class Binary : public SpecificExpression { +public: + Binary() = default; + Binary(MixedArena& allocator) {} + + BinaryOp op; + Expression* left; + Expression* right; + + // the type is always the type of the operands, + // except for relationals + + bool isRelational(); + + void finalize(); +}; + +class Select : public SpecificExpression { +public: + Select() = default; + Select(MixedArena& allocator) {} + + Expression* ifTrue; + Expression* ifFalse; + Expression* condition; + + void finalize(); + void finalize(Type type_); +}; + +class Drop : public SpecificExpression { +public: + Drop() = default; + Drop(MixedArena& allocator) {} + + Expression* value; + + void finalize(); +}; + +class Return : public SpecificExpression { +public: + Return() { type = Type::unreachable; } + Return(MixedArena& allocator) : Return() {} + + Expression* value = nullptr; +}; + +class MemorySize : public SpecificExpression { +public: + MemorySize() { type = Type::i32; } + MemorySize(MixedArena& allocator) : MemorySize() {} + + Type ptrType = Type::i32; + + void make64(); + void finalize(); +}; + +class MemoryGrow : public SpecificExpression { +public: + MemoryGrow() { type = Type::i32; } + MemoryGrow(MixedArena& allocator) : MemoryGrow() {} + + Expression* delta = nullptr; + Type ptrType = Type::i32; + + void make64(); + void finalize(); +}; + +class Unreachable : public SpecificExpression { +public: + Unreachable() { type = Type::unreachable; } + Unreachable(MixedArena& allocator) : Unreachable() {} +}; + +// Represents a pop of a value that arrives as an implicit argument to the +// current block. Currently used in exception handling. +class Pop : public SpecificExpression { +public: + Pop() = default; + Pop(MixedArena& allocator) {} +}; + +class RefNull : public SpecificExpression { +public: + RefNull() = default; + RefNull(MixedArena& allocator) {} + + void finalize(); + void finalize(HeapType heapType); + void finalize(Type type); +}; + +class RefIsNull : public SpecificExpression { +public: + RefIsNull(MixedArena& allocator) {} + + Expression* value; + + void finalize(); +}; + +class RefFunc : public SpecificExpression { +public: + RefFunc(MixedArena& allocator) {} + + Name func; + + void finalize(); +}; + +class RefEq : public SpecificExpression { +public: + RefEq(MixedArena& allocator) {} + + Expression* left; + Expression* right; + + void finalize(); +}; + +class Try : public SpecificExpression { +public: + Try(MixedArena& allocator) {} + + Expression* body; + Expression* catchBody; + + void finalize(); + void finalize(Type type_); +}; + +class Throw : public SpecificExpression { +public: + Throw(MixedArena& allocator) : operands(allocator) {} + + Name event; + ExpressionList operands; + + void finalize(); +}; + +class Rethrow : public SpecificExpression { +public: + Rethrow(MixedArena& allocator) {} + + Expression* exnref; + + void finalize(); +}; + +class BrOnExn : public SpecificExpression { +public: + BrOnExn() { type = Type::unreachable; } + BrOnExn(MixedArena& allocator) : BrOnExn() {} + + Name name; + Name event; + Expression* exnref; + // This is duplicate info of param types stored in Event, but this is required + // for us to know the type of the value sent to the target block. + Type sent; + + void finalize(); +}; + +class TupleMake : public SpecificExpression { +public: + TupleMake(MixedArena& allocator) : operands(allocator) {} + + ExpressionList operands; + + void finalize(); +}; + +class TupleExtract : public SpecificExpression { +public: + TupleExtract(MixedArena& allocator) {} + + Expression* tuple; + Index index; + + void finalize(); +}; + +class I31New : public SpecificExpression { +public: + I31New(MixedArena& allocator) {} + + Expression* value; + + void finalize(); +}; + +class I31Get : public SpecificExpression { +public: + I31Get(MixedArena& allocator) {} + + Expression* i31; + bool signed_; + + void finalize(); +}; + +class RefTest : public SpecificExpression { +public: + RefTest(MixedArena& allocator) {} + + void finalize() { WASM_UNREACHABLE("TODO (gc): ref.test"); } +}; + +class RefCast : public SpecificExpression { +public: + RefCast(MixedArena& allocator) {} + + void finalize() { WASM_UNREACHABLE("TODO (gc): ref.cast"); } +}; + +class BrOnCast : public SpecificExpression { +public: + BrOnCast(MixedArena& allocator) {} + + void finalize() { WASM_UNREACHABLE("TODO (gc): br_on_cast"); } +}; + +class RttCanon : public SpecificExpression { +public: + RttCanon(MixedArena& allocator) {} + + void finalize() { WASM_UNREACHABLE("TODO (gc): rtt.canon"); } +}; + +class RttSub : public SpecificExpression { +public: + RttSub(MixedArena& allocator) {} + + void finalize() { WASM_UNREACHABLE("TODO (gc): rtt.sub"); } +}; + +class StructNew : public SpecificExpression { +public: + StructNew(MixedArena& allocator) {} + + void finalize() { WASM_UNREACHABLE("TODO (gc): struct.new"); } +}; + +class StructGet : public SpecificExpression { +public: + StructGet(MixedArena& allocator) {} + + void finalize() { WASM_UNREACHABLE("TODO (gc): struct.get"); } +}; + +class StructSet : public SpecificExpression { +public: + StructSet(MixedArena& allocator) {} + + void finalize() { WASM_UNREACHABLE("TODO (gc): struct.set"); } +}; + +class ArrayNew : public SpecificExpression { +public: + ArrayNew(MixedArena& allocator) {} + + void finalize() { WASM_UNREACHABLE("TODO (gc): array.new"); } +}; + +class ArrayGet : public SpecificExpression { +public: + ArrayGet(MixedArena& allocator) {} + + void finalize() { WASM_UNREACHABLE("TODO (gc): array.get"); } +}; + +class ArraySet : public SpecificExpression { +public: + ArraySet(MixedArena& allocator) {} + + void finalize() { WASM_UNREACHABLE("TODO (gc): array.set"); } +}; + +class ArrayLen : public SpecificExpression { +public: + ArrayLen(MixedArena& allocator) {} + + void finalize() { WASM_UNREACHABLE("TODO (gc): array.len"); } +}; + +// Globals + +struct Importable { + // If these are set, then this is an import, as module.base + Name module, base; + + bool imported() { return module.is(); } +}; + +class Function; + +// Represents an offset into a wasm binary file. This is used for debug info. +// For now, assume this is 32 bits as that's the size limit of wasm files +// anyhow. +using BinaryLocation = uint32_t; + +// Represents a mapping of wasm module elements to their location in the +// binary representation. This is used for general debugging info support. +// Offsets are relative to the beginning of the code section, as in DWARF. +struct BinaryLocations { + struct Span { + BinaryLocation start = 0, end = 0; + }; + + // Track the range of addresses an expressions appears at. This is the + // contiguous range that all instructions have - control flow instructions + // have additional opcodes later (like an end for a block or loop), see + // just after this. + std::unordered_map expressions; + + // Track the extra delimiter positions that some instructions, in particular + // control flow, have, like 'end' for loop and block. We keep these in a + // separate map because they are rare and we optimize for the storage space + // for the common type of instruction which just needs a Span. We implement + // this as a simple struct with two elements (as two extra elements is the + // maximum currently needed; due to 'catch' and 'end' for try-catch). The + // second value may be 0, indicating it is not used. + struct DelimiterLocations : public std::array { + DelimiterLocations() { + // Ensure zero-initialization. + for (auto& item : *this) { + item = 0; + } + } + }; + + enum DelimiterId { + // All control flow structures have an end, so use index 0 for that. + End = 0, + // Use index 1 for all other current things. + Else = 1, + Catch = 1, + Invalid = -1 + }; + std::unordered_map delimiters; + + // DWARF debug info can refer to multiple interesting positions in a function. + struct FunctionLocations { + // The very start of the function, where the binary has a size LEB. + BinaryLocation start = 0; + // The area where we declare locals, which is right after the size LEB. + BinaryLocation declarations = 0; + // The end, which is one past the final "end" instruction byte. + BinaryLocation end = 0; + }; + + std::unordered_map functions; +}; + +// Forward declarations of Stack IR, as functions can contain it, see +// the stackIR property. +// Stack IR is a secondary IR to the main IR defined in this file (Binaryen +// IR). See wasm-stack.h. +class StackInst; + +using StackIR = std::vector; + +class Function : public Importable { +public: + Name name; + Signature sig; // parameters and return value + IRProfile profile = IRProfile::Normal; + std::vector vars; // non-param locals + + // The body of the function + Expression* body = nullptr; + + // If present, this stack IR was generated from the main Binaryen IR body, + // and possibly optimized. If it is present when writing to wasm binary, + // it will be emitted instead of the main Binaryen IR. + // + // Note that no special care is taken to synchronize the two IRs - if you + // emit stack IR and then optimize the main IR, you need to recompute the + // stack IR. The Pass system will throw away Stack IR if a pass is run + // that declares it may modify Binaryen IR. + std::unique_ptr stackIR; + + // local names. these are optional. + std::map localNames; + std::map localIndices; + + // Source maps debugging info: map expression nodes to their file, line, col. + struct DebugLocation { + BinaryLocation fileIndex, lineNumber, columnNumber; + bool operator==(const DebugLocation& other) const { + return fileIndex == other.fileIndex && lineNumber == other.lineNumber && + columnNumber == other.columnNumber; + } + bool operator!=(const DebugLocation& other) const { + return !(*this == other); + } + bool operator<(const DebugLocation& other) const { + return fileIndex != other.fileIndex + ? fileIndex < other.fileIndex + : lineNumber != other.lineNumber + ? lineNumber < other.lineNumber + : columnNumber < other.columnNumber; + } + }; + std::unordered_map debugLocations; + std::set prologLocation; + std::set epilogLocation; + + // General debugging info support: track instructions and the function itself. + std::unordered_map expressionLocations; + std::unordered_map + delimiterLocations; + BinaryLocations::FunctionLocations funcLocation; + + size_t getNumParams(); + size_t getNumVars(); + size_t getNumLocals(); + + bool isParam(Index index); + bool isVar(Index index); + + Name getLocalName(Index index); + Index getLocalIndex(Name name); + Index getVarIndexBase(); + Type getLocalType(Index index); + + Name getLocalNameOrDefault(Index index); + Name getLocalNameOrGeneric(Index index); + + bool hasLocalName(Index index) const; + void setLocalName(Index index, Name name); + + void clearNames(); + void clearDebugInfo(); +}; + +// The kind of an import or export. +enum class ExternalKind { + Function = 0, + Table = 1, + Memory = 2, + Global = 3, + Event = 4, + Invalid = -1 +}; + +class Export { +public: + // exported name - note that this is the key, as the internal name is + // non-unique (can have multiple exports for an internal, also over kinds) + Name name; + Name value; // internal name + ExternalKind kind; +}; + +class Table : public Importable { +public: + static const Address::address32_t kPageSize = 1; + static const Index kUnlimitedSize = Index(-1); + // In wasm32/64, the maximum table size is limited by a 32-bit pointer: 4GB + static const Index kMaxSize = Index(-1); + + struct Segment { + Expression* offset; + std::vector data; + Segment() = default; + Segment(Expression* offset) : offset(offset) {} + Segment(Expression* offset, std::vector& init) : offset(offset) { + data.swap(init); + } + }; + + // Currently the wasm object always 'has' one Table. It 'exists' if it has + // been defined or imported. The table can exist but be empty and have no + // defined initial or max size. + bool exists = false; + Name name; + Address initial = 0; + Address max = kMaxSize; + std::vector segments; + + Table() { name = Name::fromInt(0); } + bool hasMax() { return max != kUnlimitedSize; } + void clear() { + exists = false; + name = ""; + initial = 0; + max = kMaxSize; + segments.clear(); + } +}; + +class Memory : public Importable { +public: + static const Address::address32_t kPageSize = 64 * 1024; + static const Address::address64_t kUnlimitedSize = Address::address64_t(-1); + // In wasm32, the maximum memory size is limited by a 32-bit pointer: 4GB + static const Address::address32_t kMaxSize32 = + (uint64_t(4) * 1024 * 1024 * 1024) / kPageSize; + + struct Segment { + bool isPassive = false; + Expression* offset = nullptr; + std::vector data; // TODO: optimize + Segment() = default; + Segment(Expression* offset) : offset(offset) {} + Segment(Expression* offset, const char* init, Address size) + : offset(offset) { + data.resize(size); + std::copy_n(init, size, data.begin()); + } + Segment(Expression* offset, std::vector& init) : offset(offset) { + data.swap(init); + } + Segment(bool isPassive, Expression* offset, const char* init, Address size) + : isPassive(isPassive), offset(offset) { + data.resize(size); + std::copy_n(init, size, data.begin()); + } + }; + + bool exists = false; + Name name; + Address initial = 0; // sizes are in pages + Address max = kMaxSize32; + std::vector segments; + + // See comment in Table. + bool shared = false; + Type indexType = Type::i32; + + Memory() { name = Name::fromInt(0); } + bool hasMax() { return max != kUnlimitedSize; } + bool is64() { return indexType == Type::i64; } + void clear() { + exists = false; + name = ""; + initial = 0; + max = kMaxSize32; + segments.clear(); + shared = false; + indexType = Type::i32; + } +}; + +class Global : public Importable { +public: + Name name; + Type type; + Expression* init = nullptr; + bool mutable_ = false; +}; + +// Kinds of event attributes. +enum WasmEventAttribute : unsigned { WASM_EVENT_ATTRIBUTE_EXCEPTION = 0x0 }; + +class Event : public Importable { +public: + Name name; + // Kind of event. Currently only WASM_EVENT_ATTRIBUTE_EXCEPTION is possible. + uint32_t attribute = WASM_EVENT_ATTRIBUTE_EXCEPTION; + Signature sig; +}; + +// "Opaque" data, not part of the core wasm spec, that is held in binaries. +// May be parsed/handled by utility code elsewhere, but not in wasm.h +class UserSection { +public: + std::string name; + std::vector data; +}; + +// The optional "dylink" section is used in dynamic linking. +class DylinkSection { +public: + Index memorySize, memoryAlignment, tableSize, tableAlignment; + std::vector neededDynlibs; +}; + +class Module { +public: + // wasm contents (generally you shouldn't access these from outside, except + // maybe for iterating; use add*() and the get() functions) + std::vector> exports; + std::vector> functions; + std::vector> globals; + std::vector> events; + + Table table; + Memory memory; + Name start; + + std::vector userSections; + + // Optional user section IR representation. + std::unique_ptr dylinkSection; + + // Source maps debug info. + std::vector debugInfoFileNames; + + // `features` are the features allowed to be used in this module and should be + // respected regardless of the value of`hasFeaturesSection`. + // `hasFeaturesSection` means we read a features section and will emit one + // too. + FeatureSet features = FeatureSet::MVP; + bool hasFeaturesSection = false; + + // Module name, if specified. Serves a documentary role only. + Name name; + + MixedArena allocator; + +private: + // TODO: add a build option where Names are just indices, and then these + // methods are not needed + // exports map is by the *exported* name, which is unique + std::map exportsMap; + std::map functionsMap; + std::map globalsMap; + std::map eventsMap; + +public: + Module() = default; + + Export* getExport(Name name); + Function* getFunction(Name name); + Global* getGlobal(Name name); + Event* getEvent(Name name); + + Export* getExportOrNull(Name name); + Function* getFunctionOrNull(Name name); + Global* getGlobalOrNull(Name name); + Event* getEventOrNull(Name name); + + Export* addExport(Export* curr); + Function* addFunction(Function* curr); + Global* addGlobal(Global* curr); + Event* addEvent(Event* curr); + + Export* addExport(std::unique_ptr curr); + Function* addFunction(std::unique_ptr curr); + Global* addGlobal(std::unique_ptr curr); + Event* addEvent(std::unique_ptr curr); + + void addStart(const Name& s); + + void removeExport(Name name); + void removeFunction(Name name); + void removeGlobal(Name name); + void removeEvent(Name name); + + void removeExports(std::function pred); + void removeFunctions(std::function pred); + void removeGlobals(std::function pred); + void removeEvents(std::function pred); + + void updateMaps(); + + void clearDebugInfo(); +}; + +} // namespace wasm + +namespace std { +template<> struct hash { + size_t operator()(const wasm::Address a) const { + return std::hash()(a.addr); + } +}; +} // namespace std + +#endif // wasm_wasm_h diff --git a/binaryen/src/wasm/CMakeLists.txt b/binaryen/src/wasm/CMakeLists.txt new file mode 100644 --- /dev/null +++ b/binaryen/src/wasm/CMakeLists.txt @@ -0,0 +1,17 @@ +file(GLOB wasm_HEADERS ../*.h) +set(wasm_SOURCES + literal.cpp + wasm.cpp + wasm-binary.cpp + wasm-debug.cpp + wasm-emscripten.cpp + wasm-debug.cpp + wasm-interpreter.cpp + wasm-io.cpp + wasm-s-parser.cpp + wasm-stack.cpp + wasm-type.cpp + wasm-validator.cpp + ${wasm_HEADERS} +) +add_library(wasm OBJECT ${wasm_SOURCES}) diff --git a/binaryen/src/wasm/literal.cpp b/binaryen/src/wasm/literal.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/wasm/literal.cpp @@ -0,0 +1,2288 @@ +/* + * Copyright 2016 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "literal.h" + +#include +#include + +#include "emscripten-optimizer/simple_ast.h" +#include "ir/bits.h" +#include "pretty_printing.h" +#include "support/bits.h" +#include "support/utilities.h" + +namespace wasm { + +template using LaneArray = std::array; + +Literal::Literal(Type type) : type(type) { + if (type == Type::i31ref) { + // i31ref is special in that it is non-nullable, so we construct with zero + i32 = 0; + } else { + assert(type != Type::unreachable && (!type.isRef() || type.isNullable())); + if (type.isException()) { + new (&exn) std::unique_ptr(); + } else { + memset(&v128, 0, 16); + } + } +} + +Literal::Literal(const uint8_t init[16]) : type(Type::v128) { + memcpy(&v128, init, 16); +} + +Literal::Literal(const Literal& other) : type(other.type) { + if (type.isException()) { + // Avoid calling the destructor on an uninitialized value + if (other.exn != nullptr) { + new (&exn) auto(std::make_unique(*other.exn)); + } else { + new (&exn) std::unique_ptr(); + } + } else if (type.isFunction()) { + func = other.func; + } else { + TODO_SINGLE_COMPOUND(type); + switch (type.getBasic()) { + case Type::i32: + case Type::f32: + case Type::i31ref: + i32 = other.i32; + break; + case Type::i64: + case Type::f64: + i64 = other.i64; + break; + case Type::v128: + memcpy(&v128, other.v128, 16); + break; + case Type::none: + break; + case Type::externref: + case Type::anyref: + case Type::eqref: + break; // null + case Type::funcref: + case Type::exnref: + case Type::unreachable: + WASM_UNREACHABLE("unexpected type"); + } + } +} + +Literal& Literal::operator=(const Literal& other) { + if (this != &other) { + this->~Literal(); + new (this) auto(other); + } + return *this; +} + +template +static void extractBytes(uint8_t (&dest)[16], const LaneArray& lanes) { + std::array bytes; + const size_t lane_width = 16 / Lanes; + for (size_t lane_index = 0; lane_index < Lanes; ++lane_index) { + uint8_t bits[16]; + lanes[lane_index].getBits(bits); + LaneT lane; + memcpy(&lane, bits, sizeof(lane)); + for (size_t offset = 0; offset < lane_width; ++offset) { + bytes.at(lane_index * lane_width + offset) = + uint8_t(lane >> (8 * offset)); + } + } + memcpy(&dest, bytes.data(), sizeof(bytes)); +} + +Literal::Literal(const LaneArray<16>& lanes) : type(Type::v128) { + extractBytes(v128, lanes); +} + +Literal::Literal(const LaneArray<8>& lanes) : type(Type::v128) { + extractBytes(v128, lanes); +} + +Literal::Literal(const LaneArray<4>& lanes) : type(Type::v128) { + extractBytes(v128, lanes); +} + +Literal::Literal(const LaneArray<2>& lanes) : type(Type::v128) { + extractBytes(v128, lanes); +} + +Literals Literal::makeZeros(Type type) { + assert(type.isConcrete()); + Literals zeroes; + for (const auto& t : type) { + zeroes.push_back(makeZero(t)); + } + return zeroes; +} + +Literals Literal::makeOnes(Type type) { + assert(type.isConcrete()); + Literals units; + for (const auto& t : type) { + units.push_back(makeOne(t)); + } + return units; +} + +Literals Literal::makeNegOnes(Type type) { + assert(type.isConcrete()); + Literals units; + for (const auto& t : type) { + units.push_back(makeNegOne(t)); + } + return units; +} + +Literal Literal::makeZero(Type type) { + assert(type.isSingle()); + if (type.isRef()) { + if (type == Type::i31ref) { + return makeI31(0); + } else { + return makeNull(type); + } + } else { + return makeFromInt32(0, type); + } +} + +Literal Literal::makeOne(Type type) { + assert(type.isNumber()); + return makeFromInt32(1, type); +} + +Literal Literal::makeNegOne(Type type) { + assert(type.isNumber()); + return makeFromInt32(-1, type); +} + +std::array Literal::getv128() const { + assert(type == Type::v128); + std::array ret; + memcpy(ret.data(), v128, sizeof(ret)); + return ret; +} + +ExceptionPackage Literal::getExceptionPackage() const { + assert(type.isException() && exn != nullptr); + return *exn; +} + +Literal Literal::castToF32() { + assert(type == Type::i32); + Literal ret(Type::f32); + ret.i32 = i32; + return ret; +} + +Literal Literal::castToF64() { + assert(type == Type::i64); + Literal ret(Type::f64); + ret.i64 = i64; + return ret; +} + +Literal Literal::castToI32() { + assert(type == Type::f32); + Literal ret(Type::i32); + ret.i32 = i32; + return ret; +} + +Literal Literal::castToI64() { + assert(type == Type::f64); + Literal ret(Type::i64); + ret.i64 = i64; + return ret; +} + +int64_t Literal::getInteger() const { + switch (type.getBasic()) { + case Type::i32: + return i32; + case Type::i64: + return i64; + default: + abort(); + } +} + +uint64_t Literal::getUnsigned() const { + switch (type.getBasic()) { + case Type::i32: + return static_cast(i32); + case Type::i64: + return i64; + default: + abort(); + } +} + +double Literal::getFloat() const { + switch (type.getBasic()) { + case Type::f32: + return getf32(); + case Type::f64: + return getf64(); + default: + abort(); + } +} + +void Literal::getBits(uint8_t (&buf)[16]) const { + memset(buf, 0, 16); + switch (type.getBasic()) { + case Type::i32: + case Type::f32: + memcpy(buf, &i32, sizeof(i32)); + break; + case Type::i64: + case Type::f64: + memcpy(buf, &i64, sizeof(i64)); + break; + case Type::v128: + memcpy(buf, &v128, sizeof(v128)); + break; + case Type::none: + case Type::unreachable: + case Type::funcref: + case Type::externref: + case Type::exnref: + case Type::anyref: + case Type::eqref: + case Type::i31ref: + WASM_UNREACHABLE("invalid type"); + } +} + +bool Literal::operator==(const Literal& other) const { + if (type != other.type) { + return false; + } + auto compareRef = [&]() { + assert(type.isRef()); + if (isNull() || other.isNull()) { + return isNull() == other.isNull(); + } + if (type.isFunction()) { + assert(func.is() && other.func.is()); + return func == other.func; + } + if (type.isException()) { + assert(exn != nullptr && other.exn != nullptr); + return *exn == *other.exn; + } + // other non-null reference type literals cannot represent concrete values, + // i.e. there is no concrete externref, anyref or eqref other than null. + WASM_UNREACHABLE("unexpected type"); + }; + if (type.isBasic()) { + switch (type.getBasic()) { + case Type::none: + return true; // special voided literal + case Type::i32: + case Type::f32: + case Type::i31ref: + return i32 == other.i32; + case Type::i64: + case Type::f64: + return i64 == other.i64; + case Type::v128: + return memcmp(v128, other.v128, 16) == 0; + case Type::funcref: + case Type::externref: + case Type::exnref: + case Type::anyref: + case Type::eqref: + return compareRef(); + case Type::unreachable: + break; + } + } else if (type.isRef()) { + return compareRef(); + } else if (type.isRtt()) { + WASM_UNREACHABLE("TODO: rtt literals"); + } + WASM_UNREACHABLE("unexpected type"); +} + +bool Literal::operator!=(const Literal& other) const { + return !(*this == other); +} + +bool Literal::isNaN() { + if (type == Type::f32 && std::isnan(getf32())) { + return true; + } + if (type == Type::f64 && std::isnan(getf64())) { + return true; + } + // TODO: SIMD? + return false; +} + +uint32_t Literal::NaNPayload(float f) { + assert(std::isnan(f) && "expected a NaN"); + // SEEEEEEE EFFFFFFF FFFFFFFF FFFFFFFF + // NaN has all-one exponent and non-zero fraction. + return ~0xff800000u & bit_cast(f); +} + +uint64_t Literal::NaNPayload(double f) { + assert(std::isnan(f) && "expected a NaN"); + // SEEEEEEE EEEEFFFF FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFF + // NaN has all-one exponent and non-zero fraction. + return ~0xfff0000000000000ull & bit_cast(f); +} + +float Literal::setQuietNaN(float f) { + assert(std::isnan(f) && "expected a NaN"); + // An SNaN is a NaN with the most significant fraction bit clear. + return bit_cast(0x00400000u | bit_cast(f)); +} + +double Literal::setQuietNaN(double f) { + assert(std::isnan(f) && "expected a NaN"); + // An SNaN is a NaN with the most significant fraction bit clear. + return bit_cast(0x0008000000000000ull | bit_cast(f)); +} + +void Literal::printFloat(std::ostream& o, float f) { + if (std::isnan(f)) { + const char* sign = std::signbit(f) ? "-" : ""; + o << sign << "nan"; + if (uint32_t payload = NaNPayload(f)) { + o << ":0x" << std::hex << payload << std::dec; + } + return; + } + printDouble(o, f); +} + +void Literal::printDouble(std::ostream& o, double d) { + if (d == 0 && std::signbit(d)) { + o << "-0"; + return; + } + if (std::isnan(d)) { + const char* sign = std::signbit(d) ? "-" : ""; + o << sign << "nan"; + if (uint64_t payload = NaNPayload(d)) { + o << ":0x" << std::hex << payload << std::dec; + } + return; + } + if (!std::isfinite(d)) { + o << (std::signbit(d) ? "-inf" : "inf"); + return; + } + const char* text = cashew::JSPrinter::numToString(d); + // spec interpreter hates floats starting with '.' + if (text[0] == '.') { + o << '0'; + } else if (text[0] == '-' && text[1] == '.') { + o << "-0"; + text++; + } + o << text; +} + +void Literal::printVec128(std::ostream& o, const std::array& v) { + o << std::hex; + for (auto i = 0; i < 16; i += 4) { + if (i) { + o << " "; + } + o << "0x" << std::setfill('0') << std::setw(8) + << uint32_t(v[i] | (v[i + 1] << 8) | (v[i + 2] << 16) | (v[i + 3] << 24)); + } + o << std::dec; +} + +std::ostream& operator<<(std::ostream& o, Literal literal) { + prepareMinorColor(o); + TODO_SINGLE_COMPOUND(literal.type); + switch (literal.type.getBasic()) { + case Type::none: + o << "?"; + break; + case Type::i32: + o << literal.geti32(); + break; + case Type::i64: + o << literal.geti64(); + break; + case Type::f32: + literal.printFloat(o, literal.getf32()); + break; + case Type::f64: + literal.printDouble(o, literal.getf64()); + break; + case Type::v128: + o << "i32x4 "; + literal.printVec128(o, literal.getv128()); + break; + case Type::funcref: + if (literal.isNull()) { + o << "funcref(null)"; + } else { + o << "funcref(" << literal.getFunc() << ")"; + } + break; + case Type::externref: + assert(literal.isNull() && "unexpected non-null externref literal"); + o << "externref(null)"; + break; + case Type::exnref: + if (literal.isNull()) { + o << "exnref(null)"; + } else { + o << "exnref(" << literal.getExceptionPackage() << ")"; + } + break; + case Type::anyref: + assert(literal.isNull() && "unexpected non-null anyref literal"); + o << "anyref(null)"; + break; + case Type::eqref: + assert(literal.isNull() && "unexpected non-null eqref literal"); + o << "eqref(null)"; + break; + case Type::i31ref: + o << "i31ref(" << literal.geti31() << ")"; + break; + case Type::unreachable: + WASM_UNREACHABLE("invalid type"); + } + restoreNormalColor(o); + return o; +} + +std::ostream& operator<<(std::ostream& o, wasm::Literals literals) { + if (literals.size() == 1) { + return o << literals[0]; + } else { + o << '('; + if (literals.size() > 0) { + o << literals[0]; + } + for (size_t i = 1; i < literals.size(); ++i) { + o << ", " << literals[i]; + } + return o << ')'; + } +} + +std::ostream& operator<<(std::ostream& o, const ExceptionPackage& exn) { + return o << exn.event << " " << exn.values; +} + +Literal Literal::countLeadingZeroes() const { + if (type == Type::i32) { + return Literal((int32_t)Bits::countLeadingZeroes(i32)); + } + if (type == Type::i64) { + return Literal((int64_t)Bits::countLeadingZeroes(i64)); + } + WASM_UNREACHABLE("invalid type"); +} + +Literal Literal::countTrailingZeroes() const { + if (type == Type::i32) { + return Literal((int32_t)Bits::countTrailingZeroes(i32)); + } + if (type == Type::i64) { + return Literal((int64_t)Bits::countTrailingZeroes(i64)); + } + WASM_UNREACHABLE("invalid type"); +} + +Literal Literal::popCount() const { + if (type == Type::i32) { + return Literal((int32_t)Bits::popCount(i32)); + } + if (type == Type::i64) { + return Literal((int64_t)Bits::popCount(i64)); + } + WASM_UNREACHABLE("invalid type"); +} + +Literal Literal::extendToSI64() const { + assert(type == Type::i32); + return Literal((int64_t)i32); +} + +Literal Literal::extendToUI64() const { + assert(type == Type::i32); + return Literal((uint64_t)(uint32_t)i32); +} + +Literal Literal::extendToF64() const { + assert(type == Type::f32); + return Literal(double(getf32())); +} + +Literal Literal::extendS8() const { + if (type == Type::i32) { + return Literal(int32_t(int8_t(geti32() & 0xFF))); + } + if (type == Type::i64) { + return Literal(int64_t(int8_t(geti64() & 0xFF))); + } + WASM_UNREACHABLE("invalid type"); +} + +Literal Literal::extendS16() const { + if (type == Type::i32) { + return Literal(int32_t(int16_t(geti32() & 0xFFFF))); + } + if (type == Type::i64) { + return Literal(int64_t(int16_t(geti64() & 0xFFFF))); + } + WASM_UNREACHABLE("invalid type"); +} + +Literal Literal::extendS32() const { + if (type == Type::i64) { + return Literal(int64_t(int32_t(geti64() & 0xFFFFFFFF))); + } + WASM_UNREACHABLE("invalid type"); +} + +Literal Literal::wrapToI32() const { + assert(type == Type::i64); + return Literal((int32_t)i64); +} + +Literal Literal::convertSIToF32() const { + if (type == Type::i32) { + return Literal(float(i32)); + } + if (type == Type::i64) { + return Literal(float(i64)); + } + WASM_UNREACHABLE("invalid type"); +} + +Literal Literal::convertUIToF32() const { + if (type == Type::i32) { + return Literal(float(uint32_t(i32))); + } + if (type == Type::i64) { + return Literal(float(uint64_t(i64))); + } + WASM_UNREACHABLE("invalid type"); +} + +Literal Literal::convertSIToF64() const { + if (type == Type::i32) { + return Literal(double(i32)); + } + if (type == Type::i64) { + return Literal(double(i64)); + } + WASM_UNREACHABLE("invalid type"); +} + +Literal Literal::convertUIToF64() const { + if (type == Type::i32) { + return Literal(double(uint32_t(i32))); + } + if (type == Type::i64) { + return Literal(double(uint64_t(i64))); + } + WASM_UNREACHABLE("invalid type"); +} + +template struct AsInt { using type = void; }; +template<> struct AsInt { using type = int32_t; }; +template<> struct AsInt { using type = int64_t; }; + +template::type)> +static Literal saturating_trunc(typename AsInt::type val) { + if (std::isnan(bit_cast(val))) { + return Literal(I(0)); + } + if (!RangeCheck(val)) { + if (std::signbit(bit_cast(val))) { + return Literal(std::numeric_limits::min()); + } else { + return Literal(std::numeric_limits::max()); + } + } + return Literal(I(std::trunc(bit_cast(val)))); +} + +Literal Literal::truncSatToSI32() const { + if (type == Type::f32) { + return saturating_trunc( + Literal(*this).castToI32().geti32()); + } + if (type == Type::f64) { + return saturating_trunc( + Literal(*this).castToI64().geti64()); + } + WASM_UNREACHABLE("invalid type"); +} + +Literal Literal::truncSatToSI64() const { + if (type == Type::f32) { + return saturating_trunc( + Literal(*this).castToI32().geti32()); + } + if (type == Type::f64) { + return saturating_trunc( + Literal(*this).castToI64().geti64()); + } + WASM_UNREACHABLE("invalid type"); +} + +Literal Literal::truncSatToUI32() const { + if (type == Type::f32) { + return saturating_trunc( + Literal(*this).castToI32().geti32()); + } + if (type == Type::f64) { + return saturating_trunc( + Literal(*this).castToI64().geti64()); + } + WASM_UNREACHABLE("invalid type"); +} + +Literal Literal::truncSatToUI64() const { + if (type == Type::f32) { + return saturating_trunc( + Literal(*this).castToI32().geti32()); + } + if (type == Type::f64) { + return saturating_trunc( + Literal(*this).castToI64().geti64()); + } + WASM_UNREACHABLE("invalid type"); +} + +Literal Literal::eqz() const { + switch (type.getBasic()) { + case Type::i32: + return eq(Literal(int32_t(0))); + case Type::i64: + return eq(Literal(int64_t(0))); + case Type::f32: + return eq(Literal(float(0))); + case Type::f64: + return eq(Literal(double(0))); + case Type::v128: + case Type::funcref: + case Type::externref: + case Type::exnref: + case Type::anyref: + case Type::eqref: + case Type::i31ref: + case Type::none: + case Type::unreachable: + WASM_UNREACHABLE("unexpected type"); + } + WASM_UNREACHABLE("invalid type"); +} + +Literal Literal::neg() const { + switch (type.getBasic()) { + case Type::i32: + return Literal(-uint32_t(i32)); + case Type::i64: + return Literal(-uint64_t(i64)); + case Type::f32: + return Literal(i32 ^ 0x80000000).castToF32(); + case Type::f64: + return Literal(int64_t(i64 ^ 0x8000000000000000ULL)).castToF64(); + case Type::v128: + case Type::funcref: + case Type::externref: + case Type::exnref: + case Type::anyref: + case Type::eqref: + case Type::i31ref: + case Type::none: + case Type::unreachable: + WASM_UNREACHABLE("unexpected type"); + } + WASM_UNREACHABLE("invalid type"); +} + +Literal Literal::abs() const { + switch (type.getBasic()) { + case Type::i32: + return Literal(std::abs(i32)); + case Type::i64: + return Literal(std::abs(i64)); + case Type::f32: + return Literal(i32 & 0x7fffffff).castToF32(); + case Type::f64: + return Literal(int64_t(i64 & 0x7fffffffffffffffULL)).castToF64(); + case Type::v128: + case Type::funcref: + case Type::externref: + case Type::exnref: + case Type::anyref: + case Type::eqref: + case Type::i31ref: + case Type::none: + case Type::unreachable: + WASM_UNREACHABLE("unexpected type"); + } + WASM_UNREACHABLE("unexpected type"); +} + +Literal Literal::ceil() const { + switch (type.getBasic()) { + case Type::f32: + return Literal(std::ceil(getf32())); + case Type::f64: + return Literal(std::ceil(getf64())); + default: + WASM_UNREACHABLE("unexpected type"); + } +} + +Literal Literal::floor() const { + switch (type.getBasic()) { + case Type::f32: + return Literal(std::floor(getf32())); + case Type::f64: + return Literal(std::floor(getf64())); + default: + WASM_UNREACHABLE("unexpected type"); + } +} + +Literal Literal::trunc() const { + switch (type.getBasic()) { + case Type::f32: + return Literal(std::trunc(getf32())); + case Type::f64: + return Literal(std::trunc(getf64())); + default: + WASM_UNREACHABLE("unexpected type"); + } +} + +Literal Literal::nearbyint() const { + switch (type.getBasic()) { + case Type::f32: + return Literal(std::nearbyint(getf32())); + case Type::f64: + return Literal(std::nearbyint(getf64())); + default: + WASM_UNREACHABLE("unexpected type"); + } +} + +Literal Literal::sqrt() const { + switch (type.getBasic()) { + case Type::f32: + return Literal(std::sqrt(getf32())); + case Type::f64: + return Literal(std::sqrt(getf64())); + default: + WASM_UNREACHABLE("unexpected type"); + } +} + +Literal Literal::demote() const { + auto f64 = getf64(); + if (std::isnan(f64)) { + return Literal(float(f64)); + } + if (std::isinf(f64)) { + return Literal(float(f64)); + } + // when close to the limit, but still truncatable to a valid value, do that + // see + // https://github.com/WebAssembly/sexpr-wasm-prototype/blob/2d375e8d502327e814d62a08f22da9d9b6b675dc/src/wasm-interpreter.c#L247 + uint64_t bits = reinterpreti64(); + if (bits > 0x47efffffe0000000ULL && bits < 0x47effffff0000000ULL) { + return Literal(std::numeric_limits::max()); + } + if (bits > 0xc7efffffe0000000ULL && bits < 0xc7effffff0000000ULL) { + return Literal(-std::numeric_limits::max()); + } + // when we must convert to infinity, do that + if (f64 < -std::numeric_limits::max()) { + return Literal(-std::numeric_limits::infinity()); + } + if (f64 > std::numeric_limits::max()) { + return Literal(std::numeric_limits::infinity()); + } + return Literal(float(getf64())); +} + +Literal Literal::add(const Literal& other) const { + switch (type.getBasic()) { + case Type::i32: + return Literal(uint32_t(i32) + uint32_t(other.i32)); + case Type::i64: + return Literal(uint64_t(i64) + uint64_t(other.i64)); + case Type::f32: + return Literal(getf32() + other.getf32()); + case Type::f64: + return Literal(getf64() + other.getf64()); + case Type::v128: + case Type::funcref: + case Type::externref: + case Type::exnref: + case Type::anyref: + case Type::eqref: + case Type::i31ref: + case Type::none: + case Type::unreachable: + WASM_UNREACHABLE("unexpected type"); + } + WASM_UNREACHABLE("unexpected type"); +} + +Literal Literal::sub(const Literal& other) const { + switch (type.getBasic()) { + case Type::i32: + return Literal(uint32_t(i32) - uint32_t(other.i32)); + case Type::i64: + return Literal(uint64_t(i64) - uint64_t(other.i64)); + case Type::f32: + return Literal(getf32() - other.getf32()); + case Type::f64: + return Literal(getf64() - other.getf64()); + case Type::v128: + case Type::funcref: + case Type::externref: + case Type::exnref: + case Type::anyref: + case Type::eqref: + case Type::i31ref: + case Type::none: + case Type::unreachable: + WASM_UNREACHABLE("unexpected type"); + } + WASM_UNREACHABLE("unexpected type"); +} + +template static T add_sat_s(T a, T b) { + static_assert(std::is_signed::value, + "Trying to instantiate add_sat_s with unsigned type"); + using UT = typename std::make_unsigned::type; + UT ua = static_cast(a); + UT ub = static_cast(b); + UT ures = ua + ub; + // overflow if sign of result is different from sign of a and b + if (static_cast((ures ^ ua) & (ures ^ ub)) < 0) { + return (a < 0) ? std::numeric_limits::min() + : std::numeric_limits::max(); + } + return static_cast(ures); +} + +template static T sub_sat_s(T a, T b) { + static_assert(std::is_signed::value, + "Trying to instantiate sub_sat_s with unsigned type"); + using UT = typename std::make_unsigned::type; + UT ua = static_cast(a); + UT ub = static_cast(b); + UT ures = ua - ub; + // overflow if a and b have different signs and result and a differ in sign + if (static_cast((ua ^ ub) & (ures ^ ua)) < 0) { + return (a < 0) ? std::numeric_limits::min() + : std::numeric_limits::max(); + } + return static_cast(ures); +} + +template static T add_sat_u(T a, T b) { + static_assert(std::is_unsigned::value, + "Trying to instantiate add_sat_u with signed type"); + T res = a + b; + // overflow if result is less than arguments + return (res < a) ? std::numeric_limits::max() : res; +} + +template static T sub_sat_u(T a, T b) { + static_assert(std::is_unsigned::value, + "Trying to instantiate sub_sat_u with signed type"); + T res = a - b; + // overflow if result is greater than a + return (res > a) ? 0 : res; +} + +Literal Literal::addSatSI8(const Literal& other) const { + return Literal(add_sat_s(geti32(), other.geti32())); +} +Literal Literal::addSatUI8(const Literal& other) const { + return Literal(add_sat_u(geti32(), other.geti32())); +} +Literal Literal::addSatSI16(const Literal& other) const { + return Literal(add_sat_s(geti32(), other.geti32())); +} +Literal Literal::addSatUI16(const Literal& other) const { + return Literal(add_sat_u(geti32(), other.geti32())); +} +Literal Literal::subSatSI8(const Literal& other) const { + return Literal(sub_sat_s(geti32(), other.geti32())); +} +Literal Literal::subSatUI8(const Literal& other) const { + return Literal(sub_sat_u(geti32(), other.geti32())); +} +Literal Literal::subSatSI16(const Literal& other) const { + return Literal(sub_sat_s(geti32(), other.geti32())); +} +Literal Literal::subSatUI16(const Literal& other) const { + return Literal(sub_sat_u(geti32(), other.geti32())); +} + +Literal Literal::mul(const Literal& other) const { + switch (type.getBasic()) { + case Type::i32: + return Literal(uint32_t(i32) * uint32_t(other.i32)); + case Type::i64: + return Literal(uint64_t(i64) * uint64_t(other.i64)); + case Type::f32: + return Literal(getf32() * other.getf32()); + case Type::f64: + return Literal(getf64() * other.getf64()); + case Type::v128: + case Type::funcref: + case Type::externref: + case Type::exnref: + case Type::anyref: + case Type::eqref: + case Type::i31ref: + case Type::none: + case Type::unreachable: + WASM_UNREACHABLE("unexpected type"); + } + WASM_UNREACHABLE("unexpected type"); +} + +Literal Literal::div(const Literal& other) const { + switch (type.getBasic()) { + case Type::f32: { + float lhs = getf32(), rhs = other.getf32(); + float sign = std::signbit(lhs) == std::signbit(rhs) ? 0.f : -0.f; + switch (std::fpclassify(rhs)) { + case FP_ZERO: + switch (std::fpclassify(lhs)) { + case FP_NAN: + return Literal(setQuietNaN(lhs)); + case FP_ZERO: + return Literal( + std::copysign(std::numeric_limits::quiet_NaN(), sign)); + case FP_NORMAL: // fallthrough + case FP_SUBNORMAL: // fallthrough + case FP_INFINITE: + return Literal( + std::copysign(std::numeric_limits::infinity(), sign)); + default: + WASM_UNREACHABLE("invalid fp classification"); + } + case FP_NAN: // fallthrough + case FP_INFINITE: // fallthrough + case FP_NORMAL: // fallthrough + case FP_SUBNORMAL: + return Literal(lhs / rhs); + default: + WASM_UNREACHABLE("invalid fp classification"); + } + } + case Type::f64: { + double lhs = getf64(), rhs = other.getf64(); + double sign = std::signbit(lhs) == std::signbit(rhs) ? 0. : -0.; + switch (std::fpclassify(rhs)) { + case FP_ZERO: + switch (std::fpclassify(lhs)) { + case FP_NAN: + return Literal(setQuietNaN(lhs)); + case FP_ZERO: + return Literal( + std::copysign(std::numeric_limits::quiet_NaN(), sign)); + case FP_NORMAL: // fallthrough + case FP_SUBNORMAL: // fallthrough + case FP_INFINITE: + return Literal( + std::copysign(std::numeric_limits::infinity(), sign)); + default: + WASM_UNREACHABLE("invalid fp classification"); + } + case FP_NAN: // fallthrough + case FP_INFINITE: // fallthrough + case FP_NORMAL: // fallthrough + case FP_SUBNORMAL: + return Literal(lhs / rhs); + default: + WASM_UNREACHABLE("invalid fp classification"); + } + } + default: + WASM_UNREACHABLE("unexpected type"); + } +} + +Literal Literal::divS(const Literal& other) const { + switch (type.getBasic()) { + case Type::i32: + return Literal(i32 / other.i32); + case Type::i64: + return Literal(i64 / other.i64); + default: + WASM_UNREACHABLE("unexpected type"); + } +} + +Literal Literal::divU(const Literal& other) const { + switch (type.getBasic()) { + case Type::i32: + return Literal(uint32_t(i32) / uint32_t(other.i32)); + case Type::i64: + return Literal(uint64_t(i64) / uint64_t(other.i64)); + default: + WASM_UNREACHABLE("unexpected type"); + } +} + +Literal Literal::remS(const Literal& other) const { + switch (type.getBasic()) { + case Type::i32: + return Literal(i32 % other.i32); + case Type::i64: + return Literal(i64 % other.i64); + default: + WASM_UNREACHABLE("unexpected type"); + } +} + +Literal Literal::remU(const Literal& other) const { + switch (type.getBasic()) { + case Type::i32: + return Literal(uint32_t(i32) % uint32_t(other.i32)); + case Type::i64: + return Literal(uint64_t(i64) % uint64_t(other.i64)); + default: + WASM_UNREACHABLE("unexpected type"); + } +} + +Literal Literal::minInt(const Literal& other) const { + return geti32() < other.geti32() ? *this : other; +} +Literal Literal::maxInt(const Literal& other) const { + return geti32() > other.geti32() ? *this : other; +} +Literal Literal::minUInt(const Literal& other) const { + return uint32_t(geti32()) < uint32_t(other.geti32()) ? *this : other; +} +Literal Literal::maxUInt(const Literal& other) const { + return uint32_t(geti32()) > uint32_t(other.geti32()) ? *this : other; +} + +Literal Literal::avgrUInt(const Literal& other) const { + return Literal((geti32() + other.geti32() + 1) / 2); +} + +Literal Literal::and_(const Literal& other) const { + switch (type.getBasic()) { + case Type::i32: + return Literal(i32 & other.i32); + case Type::i64: + return Literal(i64 & other.i64); + default: + WASM_UNREACHABLE("unexpected type"); + } +} + +Literal Literal::or_(const Literal& other) const { + switch (type.getBasic()) { + case Type::i32: + return Literal(i32 | other.i32); + case Type::i64: + return Literal(i64 | other.i64); + default: + WASM_UNREACHABLE("unexpected type"); + } +} + +Literal Literal::xor_(const Literal& other) const { + switch (type.getBasic()) { + case Type::i32: + return Literal(i32 ^ other.i32); + case Type::i64: + return Literal(i64 ^ other.i64); + default: + WASM_UNREACHABLE("unexpected type"); + } +} + +Literal Literal::shl(const Literal& other) const { + switch (type.getBasic()) { + case Type::i32: + return Literal(uint32_t(i32) + << Bits::getEffectiveShifts(other.i32, Type::i32)); + case Type::i64: + return Literal(uint64_t(i64) + << Bits::getEffectiveShifts(other.i64, Type::i64)); + default: + WASM_UNREACHABLE("unexpected type"); + } +} + +Literal Literal::shrS(const Literal& other) const { + switch (type.getBasic()) { + case Type::i32: + return Literal(i32 >> Bits::getEffectiveShifts(other.i32, Type::i32)); + case Type::i64: + return Literal(i64 >> Bits::getEffectiveShifts(other.i64, Type::i64)); + default: + WASM_UNREACHABLE("unexpected type"); + } +} + +Literal Literal::shrU(const Literal& other) const { + switch (type.getBasic()) { + case Type::i32: + return Literal(uint32_t(i32) >> + Bits::getEffectiveShifts(other.i32, Type::i32)); + case Type::i64: + return Literal(uint64_t(i64) >> + Bits::getEffectiveShifts(other.i64, Type::i64)); + default: + WASM_UNREACHABLE("unexpected type"); + } +} + +Literal Literal::rotL(const Literal& other) const { + switch (type.getBasic()) { + case Type::i32: + return Literal(Bits::rotateLeft(uint32_t(i32), uint32_t(other.i32))); + case Type::i64: + return Literal(Bits::rotateLeft(uint64_t(i64), uint64_t(other.i64))); + default: + WASM_UNREACHABLE("unexpected type"); + } +} + +Literal Literal::rotR(const Literal& other) const { + switch (type.getBasic()) { + case Type::i32: + return Literal(Bits::rotateRight(uint32_t(i32), uint32_t(other.i32))); + case Type::i64: + return Literal(Bits::rotateRight(uint64_t(i64), uint64_t(other.i64))); + default: + WASM_UNREACHABLE("unexpected type"); + } +} + +Literal Literal::eq(const Literal& other) const { + switch (type.getBasic()) { + case Type::i32: + return Literal(i32 == other.i32); + case Type::i64: + return Literal(i64 == other.i64); + case Type::f32: + return Literal(getf32() == other.getf32()); + case Type::f64: + return Literal(getf64() == other.getf64()); + case Type::v128: + case Type::funcref: + case Type::externref: + case Type::exnref: + case Type::anyref: + case Type::eqref: + case Type::i31ref: + case Type::none: + case Type::unreachable: + WASM_UNREACHABLE("unexpected type"); + } + WASM_UNREACHABLE("unexpected type"); +} + +Literal Literal::ne(const Literal& other) const { + switch (type.getBasic()) { + case Type::i32: + return Literal(i32 != other.i32); + case Type::i64: + return Literal(i64 != other.i64); + case Type::f32: + return Literal(getf32() != other.getf32()); + case Type::f64: + return Literal(getf64() != other.getf64()); + case Type::v128: + case Type::funcref: + case Type::externref: + case Type::exnref: + case Type::anyref: + case Type::eqref: + case Type::i31ref: + case Type::none: + case Type::unreachable: + WASM_UNREACHABLE("unexpected type"); + } + WASM_UNREACHABLE("unexpected type"); +} + +Literal Literal::ltS(const Literal& other) const { + switch (type.getBasic()) { + case Type::i32: + return Literal(i32 < other.i32); + case Type::i64: + return Literal(i64 < other.i64); + default: + WASM_UNREACHABLE("unexpected type"); + } +} + +Literal Literal::ltU(const Literal& other) const { + switch (type.getBasic()) { + case Type::i32: + return Literal(uint32_t(i32) < uint32_t(other.i32)); + case Type::i64: + return Literal(uint64_t(i64) < uint64_t(other.i64)); + default: + WASM_UNREACHABLE("unexpected type"); + } +} + +Literal Literal::lt(const Literal& other) const { + switch (type.getBasic()) { + case Type::f32: + return Literal(getf32() < other.getf32()); + case Type::f64: + return Literal(getf64() < other.getf64()); + default: + WASM_UNREACHABLE("unexpected type"); + } +} + +Literal Literal::leS(const Literal& other) const { + switch (type.getBasic()) { + case Type::i32: + return Literal(i32 <= other.i32); + case Type::i64: + return Literal(i64 <= other.i64); + default: + WASM_UNREACHABLE("unexpected type"); + } +} + +Literal Literal::leU(const Literal& other) const { + switch (type.getBasic()) { + case Type::i32: + return Literal(uint32_t(i32) <= uint32_t(other.i32)); + case Type::i64: + return Literal(uint64_t(i64) <= uint64_t(other.i64)); + default: + WASM_UNREACHABLE("unexpected type"); + } +} + +Literal Literal::le(const Literal& other) const { + switch (type.getBasic()) { + case Type::f32: + return Literal(getf32() <= other.getf32()); + case Type::f64: + return Literal(getf64() <= other.getf64()); + default: + WASM_UNREACHABLE("unexpected type"); + } +} + +Literal Literal::gtS(const Literal& other) const { + switch (type.getBasic()) { + case Type::i32: + return Literal(i32 > other.i32); + case Type::i64: + return Literal(i64 > other.i64); + default: + WASM_UNREACHABLE("unexpected type"); + } +} + +Literal Literal::gtU(const Literal& other) const { + switch (type.getBasic()) { + case Type::i32: + return Literal(uint32_t(i32) > uint32_t(other.i32)); + case Type::i64: + return Literal(uint64_t(i64) > uint64_t(other.i64)); + default: + WASM_UNREACHABLE("unexpected type"); + } +} + +Literal Literal::gt(const Literal& other) const { + switch (type.getBasic()) { + case Type::f32: + return Literal(getf32() > other.getf32()); + case Type::f64: + return Literal(getf64() > other.getf64()); + default: + WASM_UNREACHABLE("unexpected type"); + } +} + +Literal Literal::geS(const Literal& other) const { + switch (type.getBasic()) { + case Type::i32: + return Literal(i32 >= other.i32); + case Type::i64: + return Literal(i64 >= other.i64); + default: + WASM_UNREACHABLE("unexpected type"); + } +} + +Literal Literal::geU(const Literal& other) const { + switch (type.getBasic()) { + case Type::i32: + return Literal(uint32_t(i32) >= uint32_t(other.i32)); + case Type::i64: + return Literal(uint64_t(i64) >= uint64_t(other.i64)); + default: + WASM_UNREACHABLE("unexpected type"); + } +} + +Literal Literal::ge(const Literal& other) const { + switch (type.getBasic()) { + case Type::f32: + return Literal(getf32() >= other.getf32()); + case Type::f64: + return Literal(getf64() >= other.getf64()); + default: + WASM_UNREACHABLE("unexpected type"); + } +} + +Literal Literal::min(const Literal& other) const { + switch (type.getBasic()) { + case Type::f32: { + auto l = getf32(), r = other.getf32(); + if (l == r && l == 0) { + return Literal(std::signbit(l) ? l : r); + } + auto result = std::min(l, r); + bool lnan = std::isnan(l), rnan = std::isnan(r); + if (!std::isnan(result) && !lnan && !rnan) { + return Literal(result); + } + if (!lnan && !rnan) { + return Literal((int32_t)0x7fc00000).castToF32(); + } + return Literal(lnan ? l : r) + .castToI32() + .or_(Literal(0xc00000)) + .castToF32(); + } + case Type::f64: { + auto l = getf64(), r = other.getf64(); + if (l == r && l == 0) { + return Literal(std::signbit(l) ? l : r); + } + auto result = std::min(l, r); + bool lnan = std::isnan(l), rnan = std::isnan(r); + if (!std::isnan(result) && !lnan && !rnan) { + return Literal(result); + } + if (!lnan && !rnan) { + return Literal((int64_t)0x7ff8000000000000LL).castToF64(); + } + return Literal(lnan ? l : r) + .castToI64() + .or_(Literal(int64_t(0x8000000000000LL))) + .castToF64(); + } + default: + WASM_UNREACHABLE("unexpected type"); + } +} + +Literal Literal::max(const Literal& other) const { + switch (type.getBasic()) { + case Type::f32: { + auto l = getf32(), r = other.getf32(); + if (l == r && l == 0) { + return Literal(std::signbit(l) ? r : l); + } + auto result = std::max(l, r); + bool lnan = std::isnan(l), rnan = std::isnan(r); + if (!std::isnan(result) && !lnan && !rnan) { + return Literal(result); + } + if (!lnan && !rnan) { + return Literal((int32_t)0x7fc00000).castToF32(); + } + return Literal(lnan ? l : r) + .castToI32() + .or_(Literal(0xc00000)) + .castToF32(); + } + case Type::f64: { + auto l = getf64(), r = other.getf64(); + if (l == r && l == 0) { + return Literal(std::signbit(l) ? r : l); + } + auto result = std::max(l, r); + bool lnan = std::isnan(l), rnan = std::isnan(r); + if (!std::isnan(result) && !lnan && !rnan) { + return Literal(result); + } + if (!lnan && !rnan) { + return Literal((int64_t)0x7ff8000000000000LL).castToF64(); + } + return Literal(lnan ? l : r) + .castToI64() + .or_(Literal(int64_t(0x8000000000000LL))) + .castToF64(); + } + default: + WASM_UNREACHABLE("unexpected type"); + } +} + +Literal Literal::pmin(const Literal& other) const { + switch (type.getBasic()) { + case Type::f32: + case Type::f64: + return other.lt(*this).geti32() ? other : *this; + default: + WASM_UNREACHABLE("unexpected type"); + } +} + +Literal Literal::pmax(const Literal& other) const { + switch (type.getBasic()) { + case Type::f32: + case Type::f64: + return this->lt(other).geti32() ? other : *this; + default: + WASM_UNREACHABLE("unexpected type"); + } +} + +Literal Literal::copysign(const Literal& other) const { + // operate on bits directly, to avoid signalling bit being set on a float + switch (type.getBasic()) { + case Type::f32: + return Literal((i32 & 0x7fffffff) | (other.i32 & 0x80000000)).castToF32(); + break; + case Type::f64: + return Literal((i64 & 0x7fffffffffffffffUL) | + (other.i64 & 0x8000000000000000UL)) + .castToF64(); + break; + default: + WASM_UNREACHABLE("unexpected type"); + } +} + +template +static LaneArray getLanes(const Literal& val) { + assert(val.type == Type::v128); + const size_t lane_width = 16 / Lanes; + std::array bytes = val.getv128(); + LaneArray lanes; + for (size_t lane_index = 0; lane_index < Lanes; ++lane_index) { + LaneT lane(0); + for (size_t offset = 0; offset < lane_width; ++offset) { + lane |= LaneT(bytes.at(lane_index * lane_width + offset)) + << LaneT(8 * offset); + } + lanes.at(lane_index) = Literal(lane); + } + return lanes; +} + +LaneArray<16> Literal::getLanesSI8x16() const { + return getLanes(*this); +} +LaneArray<16> Literal::getLanesUI8x16() const { + return getLanes(*this); +} +LaneArray<8> Literal::getLanesSI16x8() const { + return getLanes(*this); +} +LaneArray<8> Literal::getLanesUI16x8() const { + return getLanes(*this); +} +LaneArray<4> Literal::getLanesI32x4() const { + return getLanes(*this); +} +LaneArray<2> Literal::getLanesI64x2() const { + return getLanes(*this); +} +LaneArray<4> Literal::getLanesF32x4() const { + auto lanes = getLanesI32x4(); + for (size_t i = 0; i < lanes.size(); ++i) { + lanes[i] = lanes[i].castToF32(); + } + return lanes; +} +LaneArray<2> Literal::getLanesF64x2() const { + auto lanes = getLanesI64x2(); + for (size_t i = 0; i < lanes.size(); ++i) { + lanes[i] = lanes[i].castToF64(); + } + return lanes; +} + +Literal Literal::shuffleV8x16(const Literal& other, + const std::array& mask) const { + assert(type == Type::v128); + uint8_t bytes[16]; + for (size_t i = 0; i < mask.size(); ++i) { + bytes[i] = (mask[i] < 16) ? v128[mask[i]] : other.v128[mask[i] - 16]; + } + return Literal(bytes); +} + +template static Literal splat(const Literal& val) { + assert(val.type == Ty); + LaneArray lanes; + lanes.fill(val); + return Literal(lanes); +} + +Literal Literal::splatI8x16() const { return splat(*this); } +Literal Literal::splatI16x8() const { return splat(*this); } +Literal Literal::splatI32x4() const { return splat(*this); } +Literal Literal::splatI64x2() const { return splat(*this); } +Literal Literal::splatF32x4() const { return splat(*this); } +Literal Literal::splatF64x2() const { return splat(*this); } + +Literal Literal::extractLaneSI8x16(uint8_t index) const { + return getLanesSI8x16().at(index); +} +Literal Literal::extractLaneUI8x16(uint8_t index) const { + return getLanesUI8x16().at(index); +} +Literal Literal::extractLaneSI16x8(uint8_t index) const { + return getLanesSI16x8().at(index); +} +Literal Literal::extractLaneUI16x8(uint8_t index) const { + return getLanesUI16x8().at(index); +} +Literal Literal::extractLaneI32x4(uint8_t index) const { + return getLanesI32x4().at(index); +} +Literal Literal::extractLaneI64x2(uint8_t index) const { + return getLanesI64x2().at(index); +} +Literal Literal::extractLaneF32x4(uint8_t index) const { + return getLanesF32x4().at(index); +} +Literal Literal::extractLaneF64x2(uint8_t index) const { + return getLanesF64x2().at(index); +} + +template (Literal::*IntoLanes)() const> +static Literal +replace(const Literal& val, const Literal& other, uint8_t index) { + LaneArray lanes = (val.*IntoLanes)(); + lanes.at(index) = other; + auto ret = Literal(lanes); + return ret; +} + +Literal Literal::replaceLaneI8x16(const Literal& other, uint8_t index) const { + return replace<16, &Literal::getLanesUI8x16>(*this, other, index); +} +Literal Literal::replaceLaneI16x8(const Literal& other, uint8_t index) const { + return replace<8, &Literal::getLanesUI16x8>(*this, other, index); +} +Literal Literal::replaceLaneI32x4(const Literal& other, uint8_t index) const { + return replace<4, &Literal::getLanesI32x4>(*this, other, index); +} +Literal Literal::replaceLaneI64x2(const Literal& other, uint8_t index) const { + return replace<2, &Literal::getLanesI64x2>(*this, other, index); +} +Literal Literal::replaceLaneF32x4(const Literal& other, uint8_t index) const { + return replace<4, &Literal::getLanesF32x4>(*this, other, index); +} +Literal Literal::replaceLaneF64x2(const Literal& other, uint8_t index) const { + return replace<2, &Literal::getLanesF64x2>(*this, other, index); +} + +template (Literal::*IntoLanes)() const, + Literal (Literal::*UnaryOp)(void) const> +static Literal unary(const Literal& val) { + LaneArray lanes = (val.*IntoLanes)(); + for (size_t i = 0; i < Lanes; ++i) { + lanes[i] = (lanes[i].*UnaryOp)(); + } + return Literal(lanes); +} + +Literal Literal::notV128() const { + std::array ones; + ones.fill(0xff); + return xorV128(Literal(ones.data())); +} +Literal Literal::absI8x16() const { + return unary<16, &Literal::getLanesSI8x16, &Literal::abs>(*this); +} +Literal Literal::absI16x8() const { + return unary<8, &Literal::getLanesSI16x8, &Literal::abs>(*this); +} +Literal Literal::absI32x4() const { + return unary<4, &Literal::getLanesI32x4, &Literal::abs>(*this); +} +Literal Literal::negI8x16() const { + return unary<16, &Literal::getLanesUI8x16, &Literal::neg>(*this); +} +Literal Literal::negI16x8() const { + return unary<8, &Literal::getLanesUI16x8, &Literal::neg>(*this); +} +Literal Literal::negI32x4() const { + return unary<4, &Literal::getLanesI32x4, &Literal::neg>(*this); +} +Literal Literal::negI64x2() const { + return unary<2, &Literal::getLanesI64x2, &Literal::neg>(*this); +} +Literal Literal::absF32x4() const { + return unary<4, &Literal::getLanesF32x4, &Literal::abs>(*this); +} +Literal Literal::negF32x4() const { + return unary<4, &Literal::getLanesF32x4, &Literal::neg>(*this); +} +Literal Literal::sqrtF32x4() const { + return unary<4, &Literal::getLanesF32x4, &Literal::sqrt>(*this); +} +Literal Literal::ceilF32x4() const { + return unary<4, &Literal::getLanesF32x4, &Literal::ceil>(*this); +} +Literal Literal::floorF32x4() const { + return unary<4, &Literal::getLanesF32x4, &Literal::floor>(*this); +} +Literal Literal::truncF32x4() const { + return unary<4, &Literal::getLanesF32x4, &Literal::trunc>(*this); +} +Literal Literal::nearestF32x4() const { + return unary<4, &Literal::getLanesF32x4, &Literal::nearbyint>(*this); +} +Literal Literal::absF64x2() const { + return unary<2, &Literal::getLanesF64x2, &Literal::abs>(*this); +} +Literal Literal::negF64x2() const { + return unary<2, &Literal::getLanesF64x2, &Literal::neg>(*this); +} +Literal Literal::sqrtF64x2() const { + return unary<2, &Literal::getLanesF64x2, &Literal::sqrt>(*this); +} +Literal Literal::ceilF64x2() const { + return unary<2, &Literal::getLanesF64x2, &Literal::ceil>(*this); +} +Literal Literal::floorF64x2() const { + return unary<2, &Literal::getLanesF64x2, &Literal::floor>(*this); +} +Literal Literal::truncF64x2() const { + return unary<2, &Literal::getLanesF64x2, &Literal::trunc>(*this); +} +Literal Literal::nearestF64x2() const { + return unary<2, &Literal::getLanesF64x2, &Literal::nearbyint>(*this); +} +Literal Literal::truncSatToSI32x4() const { + return unary<4, &Literal::getLanesF32x4, &Literal::truncSatToSI32>(*this); +} +Literal Literal::truncSatToUI32x4() const { + return unary<4, &Literal::getLanesF32x4, &Literal::truncSatToUI32>(*this); +} +Literal Literal::truncSatToSI64x2() const { + return unary<2, &Literal::getLanesF64x2, &Literal::truncSatToSI64>(*this); +} +Literal Literal::truncSatToUI64x2() const { + return unary<2, &Literal::getLanesF64x2, &Literal::truncSatToUI64>(*this); +} +Literal Literal::convertSToF32x4() const { + return unary<4, &Literal::getLanesI32x4, &Literal::convertSIToF32>(*this); +} +Literal Literal::convertUToF32x4() const { + return unary<4, &Literal::getLanesI32x4, &Literal::convertUIToF32>(*this); +} +Literal Literal::convertSToF64x2() const { + return unary<2, &Literal::getLanesI64x2, &Literal::convertSIToF64>(*this); +} +Literal Literal::convertUToF64x2() const { + return unary<2, &Literal::getLanesI64x2, &Literal::convertUIToF64>(*this); +} + +template (Literal::*IntoLanes)() const> +static Literal any_true(const Literal& val) { + LaneArray lanes = (val.*IntoLanes)(); + for (size_t i = 0; i < Lanes; ++i) { + if (lanes[i] != Literal::makeZero(lanes[i].type)) { + return Literal(int32_t(1)); + } + } + return Literal(int32_t(0)); +} + +template (Literal::*IntoLanes)() const> +static Literal all_true(const Literal& val) { + LaneArray lanes = (val.*IntoLanes)(); + for (size_t i = 0; i < Lanes; ++i) { + if (lanes[i] == Literal::makeZero(lanes[i].type)) { + return Literal(int32_t(0)); + } + } + return Literal(int32_t(1)); +} + +template (Literal::*IntoLanes)() const> +static Literal bitmask(const Literal& val) { + uint32_t result = 0; + LaneArray lanes = (val.*IntoLanes)(); + for (size_t i = 0; i < Lanes; ++i) { + if (lanes[i].geti32() & (1 << 31)) { + result = result | (1 << i); + } + } + return Literal(result); +} + +Literal Literal::anyTrueI8x16() const { + return any_true<16, &Literal::getLanesUI8x16>(*this); +} +Literal Literal::allTrueI8x16() const { + return all_true<16, &Literal::getLanesUI8x16>(*this); +} +Literal Literal::bitmaskI8x16() const { + return bitmask<16, &Literal::getLanesSI8x16>(*this); +} +Literal Literal::anyTrueI16x8() const { + return any_true<8, &Literal::getLanesUI16x8>(*this); +} +Literal Literal::allTrueI16x8() const { + return all_true<8, &Literal::getLanesUI16x8>(*this); +} +Literal Literal::bitmaskI16x8() const { + return bitmask<8, &Literal::getLanesSI16x8>(*this); +} +Literal Literal::anyTrueI32x4() const { + return any_true<4, &Literal::getLanesI32x4>(*this); +} +Literal Literal::allTrueI32x4() const { + return all_true<4, &Literal::getLanesI32x4>(*this); +} +Literal Literal::bitmaskI32x4() const { + return bitmask<4, &Literal::getLanesI32x4>(*this); +} +Literal Literal::anyTrueI64x2() const { + return any_true<2, &Literal::getLanesI64x2>(*this); +} +Literal Literal::allTrueI64x2() const { + return all_true<2, &Literal::getLanesI64x2>(*this); +} + +template (Literal::*IntoLanes)() const, + Literal (Literal::*ShiftOp)(const Literal&) const> +static Literal shift(const Literal& vec, const Literal& shift) { + assert(shift.type == Type::i32); + size_t lane_bits = 128 / Lanes; + LaneArray lanes = (vec.*IntoLanes)(); + for (size_t i = 0; i < Lanes; ++i) { + lanes[i] = + (lanes[i].*ShiftOp)(Literal(int32_t(shift.geti32() % lane_bits))); + } + return Literal(lanes); +} + +Literal Literal::shlI8x16(const Literal& other) const { + return shift<16, &Literal::getLanesUI8x16, &Literal::shl>(*this, other); +} +Literal Literal::shrSI8x16(const Literal& other) const { + return shift<16, &Literal::getLanesSI8x16, &Literal::shrS>(*this, other); +} +Literal Literal::shrUI8x16(const Literal& other) const { + return shift<16, &Literal::getLanesUI8x16, &Literal::shrU>(*this, other); +} +Literal Literal::shlI16x8(const Literal& other) const { + return shift<8, &Literal::getLanesUI16x8, &Literal::shl>(*this, other); +} +Literal Literal::shrSI16x8(const Literal& other) const { + return shift<8, &Literal::getLanesSI16x8, &Literal::shrS>(*this, other); +} +Literal Literal::shrUI16x8(const Literal& other) const { + return shift<8, &Literal::getLanesUI16x8, &Literal::shrU>(*this, other); +} +Literal Literal::shlI32x4(const Literal& other) const { + return shift<4, &Literal::getLanesI32x4, &Literal::shl>(*this, other); +} +Literal Literal::shrSI32x4(const Literal& other) const { + return shift<4, &Literal::getLanesI32x4, &Literal::shrS>(*this, other); +} +Literal Literal::shrUI32x4(const Literal& other) const { + return shift<4, &Literal::getLanesI32x4, &Literal::shrU>(*this, other); +} +Literal Literal::shlI64x2(const Literal& other) const { + return shift<2, &Literal::getLanesI64x2, &Literal::shl>(*this, other); +} +Literal Literal::shrSI64x2(const Literal& other) const { + return shift<2, &Literal::getLanesI64x2, &Literal::shrS>(*this, other); +} +Literal Literal::shrUI64x2(const Literal& other) const { + return shift<2, &Literal::getLanesI64x2, &Literal::shrU>(*this, other); +} + +template (Literal::*IntoLanes)() const, + Literal (Literal::*CompareOp)(const Literal&) const, + typename LaneT = int32_t> +static Literal compare(const Literal& val, const Literal& other) { + LaneArray lanes = (val.*IntoLanes)(); + LaneArray other_lanes = (other.*IntoLanes)(); + for (size_t i = 0; i < Lanes; ++i) { + lanes[i] = (lanes[i].*CompareOp)(other_lanes[i]) == Literal(int32_t(1)) + ? Literal(LaneT(-1)) + : Literal(LaneT(0)); + } + return Literal(lanes); +} + +Literal Literal::eqI8x16(const Literal& other) const { + return compare<16, &Literal::getLanesUI8x16, &Literal::eq>(*this, other); +} +Literal Literal::neI8x16(const Literal& other) const { + return compare<16, &Literal::getLanesUI8x16, &Literal::ne>(*this, other); +} +Literal Literal::ltSI8x16(const Literal& other) const { + return compare<16, &Literal::getLanesSI8x16, &Literal::ltS>(*this, other); +} +Literal Literal::ltUI8x16(const Literal& other) const { + return compare<16, &Literal::getLanesUI8x16, &Literal::ltU>(*this, other); +} +Literal Literal::gtSI8x16(const Literal& other) const { + return compare<16, &Literal::getLanesSI8x16, &Literal::gtS>(*this, other); +} +Literal Literal::gtUI8x16(const Literal& other) const { + return compare<16, &Literal::getLanesUI8x16, &Literal::gtU>(*this, other); +} +Literal Literal::leSI8x16(const Literal& other) const { + return compare<16, &Literal::getLanesSI8x16, &Literal::leS>(*this, other); +} +Literal Literal::leUI8x16(const Literal& other) const { + return compare<16, &Literal::getLanesUI8x16, &Literal::leU>(*this, other); +} +Literal Literal::geSI8x16(const Literal& other) const { + return compare<16, &Literal::getLanesSI8x16, &Literal::geS>(*this, other); +} +Literal Literal::geUI8x16(const Literal& other) const { + return compare<16, &Literal::getLanesUI8x16, &Literal::geU>(*this, other); +} +Literal Literal::eqI16x8(const Literal& other) const { + return compare<8, &Literal::getLanesUI16x8, &Literal::eq>(*this, other); +} +Literal Literal::neI16x8(const Literal& other) const { + return compare<8, &Literal::getLanesUI16x8, &Literal::ne>(*this, other); +} +Literal Literal::ltSI16x8(const Literal& other) const { + return compare<8, &Literal::getLanesSI16x8, &Literal::ltS>(*this, other); +} +Literal Literal::ltUI16x8(const Literal& other) const { + return compare<8, &Literal::getLanesUI16x8, &Literal::ltU>(*this, other); +} +Literal Literal::gtSI16x8(const Literal& other) const { + return compare<8, &Literal::getLanesSI16x8, &Literal::gtS>(*this, other); +} +Literal Literal::gtUI16x8(const Literal& other) const { + return compare<8, &Literal::getLanesUI16x8, &Literal::gtU>(*this, other); +} +Literal Literal::leSI16x8(const Literal& other) const { + return compare<8, &Literal::getLanesSI16x8, &Literal::leS>(*this, other); +} +Literal Literal::leUI16x8(const Literal& other) const { + return compare<8, &Literal::getLanesUI16x8, &Literal::leU>(*this, other); +} +Literal Literal::geSI16x8(const Literal& other) const { + return compare<8, &Literal::getLanesSI16x8, &Literal::geS>(*this, other); +} +Literal Literal::geUI16x8(const Literal& other) const { + return compare<8, &Literal::getLanesUI16x8, &Literal::geU>(*this, other); +} +Literal Literal::eqI32x4(const Literal& other) const { + return compare<4, &Literal::getLanesI32x4, &Literal::eq>(*this, other); +} +Literal Literal::neI32x4(const Literal& other) const { + return compare<4, &Literal::getLanesI32x4, &Literal::ne>(*this, other); +} +Literal Literal::ltSI32x4(const Literal& other) const { + return compare<4, &Literal::getLanesI32x4, &Literal::ltS>(*this, other); +} +Literal Literal::ltUI32x4(const Literal& other) const { + return compare<4, &Literal::getLanesI32x4, &Literal::ltU>(*this, other); +} +Literal Literal::gtSI32x4(const Literal& other) const { + return compare<4, &Literal::getLanesI32x4, &Literal::gtS>(*this, other); +} +Literal Literal::gtUI32x4(const Literal& other) const { + return compare<4, &Literal::getLanesI32x4, &Literal::gtU>(*this, other); +} +Literal Literal::leSI32x4(const Literal& other) const { + return compare<4, &Literal::getLanesI32x4, &Literal::leS>(*this, other); +} +Literal Literal::leUI32x4(const Literal& other) const { + return compare<4, &Literal::getLanesI32x4, &Literal::leU>(*this, other); +} +Literal Literal::geSI32x4(const Literal& other) const { + return compare<4, &Literal::getLanesI32x4, &Literal::geS>(*this, other); +} +Literal Literal::geUI32x4(const Literal& other) const { + return compare<4, &Literal::getLanesI32x4, &Literal::geU>(*this, other); +} +Literal Literal::eqF32x4(const Literal& other) const { + return compare<4, &Literal::getLanesF32x4, &Literal::eq>(*this, other); +} +Literal Literal::neF32x4(const Literal& other) const { + return compare<4, &Literal::getLanesF32x4, &Literal::ne>(*this, other); +} +Literal Literal::ltF32x4(const Literal& other) const { + return compare<4, &Literal::getLanesF32x4, &Literal::lt>(*this, other); +} +Literal Literal::gtF32x4(const Literal& other) const { + return compare<4, &Literal::getLanesF32x4, &Literal::gt>(*this, other); +} +Literal Literal::leF32x4(const Literal& other) const { + return compare<4, &Literal::getLanesF32x4, &Literal::le>(*this, other); +} +Literal Literal::geF32x4(const Literal& other) const { + return compare<4, &Literal::getLanesF32x4, &Literal::ge>(*this, other); +} +Literal Literal::eqF64x2(const Literal& other) const { + return compare<2, &Literal::getLanesF64x2, &Literal::eq, int64_t>(*this, + other); +} +Literal Literal::neF64x2(const Literal& other) const { + return compare<2, &Literal::getLanesF64x2, &Literal::ne, int64_t>(*this, + other); +} +Literal Literal::ltF64x2(const Literal& other) const { + return compare<2, &Literal::getLanesF64x2, &Literal::lt, int64_t>(*this, + other); +} +Literal Literal::gtF64x2(const Literal& other) const { + return compare<2, &Literal::getLanesF64x2, &Literal::gt, int64_t>(*this, + other); +} +Literal Literal::leF64x2(const Literal& other) const { + return compare<2, &Literal::getLanesF64x2, &Literal::le, int64_t>(*this, + other); +} +Literal Literal::geF64x2(const Literal& other) const { + return compare<2, &Literal::getLanesF64x2, &Literal::ge, int64_t>(*this, + other); +} + +template (Literal::*IntoLanes)() const, + Literal (Literal::*BinaryOp)(const Literal&) const> +static Literal binary(const Literal& val, const Literal& other) { + LaneArray lanes = (val.*IntoLanes)(); + LaneArray other_lanes = (other.*IntoLanes)(); + for (size_t i = 0; i < Lanes; ++i) { + lanes[i] = (lanes[i].*BinaryOp)(other_lanes[i]); + } + return Literal(lanes); +} + +Literal Literal::andV128(const Literal& other) const { + return binary<4, &Literal::getLanesI32x4, &Literal::and_>(*this, other); +} +Literal Literal::orV128(const Literal& other) const { + return binary<4, &Literal::getLanesI32x4, &Literal::or_>(*this, other); +} +Literal Literal::xorV128(const Literal& other) const { + return binary<4, &Literal::getLanesI32x4, &Literal::xor_>(*this, other); +} +Literal Literal::addI8x16(const Literal& other) const { + return binary<16, &Literal::getLanesUI8x16, &Literal::add>(*this, other); +} +Literal Literal::addSaturateSI8x16(const Literal& other) const { + return binary<16, &Literal::getLanesUI8x16, &Literal::addSatSI8>(*this, + other); +} +Literal Literal::addSaturateUI8x16(const Literal& other) const { + return binary<16, &Literal::getLanesSI8x16, &Literal::addSatUI8>(*this, + other); +} +Literal Literal::subI8x16(const Literal& other) const { + return binary<16, &Literal::getLanesUI8x16, &Literal::sub>(*this, other); +} +Literal Literal::subSaturateSI8x16(const Literal& other) const { + return binary<16, &Literal::getLanesUI8x16, &Literal::subSatSI8>(*this, + other); +} +Literal Literal::subSaturateUI8x16(const Literal& other) const { + return binary<16, &Literal::getLanesSI8x16, &Literal::subSatUI8>(*this, + other); +} +Literal Literal::mulI8x16(const Literal& other) const { + return binary<16, &Literal::getLanesUI8x16, &Literal::mul>(*this, other); +} +Literal Literal::minSI8x16(const Literal& other) const { + return binary<16, &Literal::getLanesSI8x16, &Literal::minInt>(*this, other); +} +Literal Literal::minUI8x16(const Literal& other) const { + return binary<16, &Literal::getLanesUI8x16, &Literal::minInt>(*this, other); +} +Literal Literal::maxSI8x16(const Literal& other) const { + return binary<16, &Literal::getLanesSI8x16, &Literal::maxInt>(*this, other); +} +Literal Literal::maxUI8x16(const Literal& other) const { + return binary<16, &Literal::getLanesUI8x16, &Literal::maxInt>(*this, other); +} +Literal Literal::avgrUI8x16(const Literal& other) const { + return binary<16, &Literal::getLanesUI8x16, &Literal::avgrUInt>(*this, other); +} +Literal Literal::addI16x8(const Literal& other) const { + return binary<8, &Literal::getLanesUI16x8, &Literal::add>(*this, other); +} +Literal Literal::addSaturateSI16x8(const Literal& other) const { + return binary<8, &Literal::getLanesUI16x8, &Literal::addSatSI16>(*this, + other); +} +Literal Literal::addSaturateUI16x8(const Literal& other) const { + return binary<8, &Literal::getLanesSI16x8, &Literal::addSatUI16>(*this, + other); +} +Literal Literal::subI16x8(const Literal& other) const { + return binary<8, &Literal::getLanesUI16x8, &Literal::sub>(*this, other); +} +Literal Literal::subSaturateSI16x8(const Literal& other) const { + return binary<8, &Literal::getLanesUI16x8, &Literal::subSatSI16>(*this, + other); +} +Literal Literal::subSaturateUI16x8(const Literal& other) const { + return binary<8, &Literal::getLanesSI16x8, &Literal::subSatUI16>(*this, + other); +} +Literal Literal::mulI16x8(const Literal& other) const { + return binary<8, &Literal::getLanesUI16x8, &Literal::mul>(*this, other); +} +Literal Literal::minSI16x8(const Literal& other) const { + return binary<8, &Literal::getLanesSI16x8, &Literal::minInt>(*this, other); +} +Literal Literal::minUI16x8(const Literal& other) const { + return binary<8, &Literal::getLanesUI16x8, &Literal::minInt>(*this, other); +} +Literal Literal::maxSI16x8(const Literal& other) const { + return binary<8, &Literal::getLanesSI16x8, &Literal::maxInt>(*this, other); +} +Literal Literal::maxUI16x8(const Literal& other) const { + return binary<8, &Literal::getLanesUI16x8, &Literal::maxInt>(*this, other); +} +Literal Literal::avgrUI16x8(const Literal& other) const { + return binary<8, &Literal::getLanesUI16x8, &Literal::avgrUInt>(*this, other); +} +Literal Literal::addI32x4(const Literal& other) const { + return binary<4, &Literal::getLanesI32x4, &Literal::add>(*this, other); +} +Literal Literal::subI32x4(const Literal& other) const { + return binary<4, &Literal::getLanesI32x4, &Literal::sub>(*this, other); +} +Literal Literal::mulI32x4(const Literal& other) const { + return binary<4, &Literal::getLanesI32x4, &Literal::mul>(*this, other); +} +Literal Literal::minSI32x4(const Literal& other) const { + return binary<4, &Literal::getLanesI32x4, &Literal::minInt>(*this, other); +} +Literal Literal::minUI32x4(const Literal& other) const { + return binary<4, &Literal::getLanesI32x4, &Literal::minUInt>(*this, other); +} +Literal Literal::maxSI32x4(const Literal& other) const { + return binary<4, &Literal::getLanesI32x4, &Literal::maxInt>(*this, other); +} +Literal Literal::maxUI32x4(const Literal& other) const { + return binary<4, &Literal::getLanesI32x4, &Literal::maxUInt>(*this, other); +} +Literal Literal::addI64x2(const Literal& other) const { + return binary<2, &Literal::getLanesI64x2, &Literal::add>(*this, other); +} +Literal Literal::subI64x2(const Literal& other) const { + return binary<2, &Literal::getLanesI64x2, &Literal::sub>(*this, other); +} +Literal Literal::mulI64x2(const Literal& other) const { + return binary<2, &Literal::getLanesI64x2, &Literal::mul>(*this, other); +} +Literal Literal::addF32x4(const Literal& other) const { + return binary<4, &Literal::getLanesF32x4, &Literal::add>(*this, other); +} +Literal Literal::subF32x4(const Literal& other) const { + return binary<4, &Literal::getLanesF32x4, &Literal::sub>(*this, other); +} +Literal Literal::mulF32x4(const Literal& other) const { + return binary<4, &Literal::getLanesF32x4, &Literal::mul>(*this, other); +} +Literal Literal::divF32x4(const Literal& other) const { + return binary<4, &Literal::getLanesF32x4, &Literal::div>(*this, other); +} +Literal Literal::minF32x4(const Literal& other) const { + return binary<4, &Literal::getLanesF32x4, &Literal::min>(*this, other); +} +Literal Literal::maxF32x4(const Literal& other) const { + return binary<4, &Literal::getLanesF32x4, &Literal::max>(*this, other); +} +Literal Literal::pminF32x4(const Literal& other) const { + return binary<4, &Literal::getLanesF32x4, &Literal::pmin>(*this, other); +} +Literal Literal::pmaxF32x4(const Literal& other) const { + return binary<4, &Literal::getLanesF32x4, &Literal::pmax>(*this, other); +} +Literal Literal::addF64x2(const Literal& other) const { + return binary<2, &Literal::getLanesF64x2, &Literal::add>(*this, other); +} +Literal Literal::subF64x2(const Literal& other) const { + return binary<2, &Literal::getLanesF64x2, &Literal::sub>(*this, other); +} +Literal Literal::mulF64x2(const Literal& other) const { + return binary<2, &Literal::getLanesF64x2, &Literal::mul>(*this, other); +} +Literal Literal::divF64x2(const Literal& other) const { + return binary<2, &Literal::getLanesF64x2, &Literal::div>(*this, other); +} +Literal Literal::minF64x2(const Literal& other) const { + return binary<2, &Literal::getLanesF64x2, &Literal::min>(*this, other); +} +Literal Literal::maxF64x2(const Literal& other) const { + return binary<2, &Literal::getLanesF64x2, &Literal::max>(*this, other); +} +Literal Literal::pminF64x2(const Literal& other) const { + return binary<2, &Literal::getLanesF64x2, &Literal::pmin>(*this, other); +} +Literal Literal::pmaxF64x2(const Literal& other) const { + return binary<2, &Literal::getLanesF64x2, &Literal::pmax>(*this, other); +} + +Literal Literal::dotSI16x8toI32x4(const Literal& other) const { + LaneArray<8> lhs = getLanesSI16x8(); + LaneArray<8> rhs = other.getLanesSI16x8(); + LaneArray<4> result; + for (size_t i = 0; i < 4; ++i) { + result[i] = Literal(lhs[i * 2].geti32() * rhs[i * 2].geti32() + + lhs[i * 2 + 1].geti32() * rhs[i * 2 + 1].geti32()); + } + return Literal(result); +} + +Literal Literal::bitselectV128(const Literal& left, + const Literal& right) const { + return andV128(left).orV128(notV128().andV128(right)); +} + +template struct TwiceWidth {}; +template<> struct TwiceWidth { using type = int16_t; }; +template<> struct TwiceWidth { using type = int32_t; }; + +template +Literal saturating_narrow( + typename TwiceWidth::type>::type val) { + using WideT = typename TwiceWidth::type>::type; + if (val > WideT(std::numeric_limits::max())) { + val = std::numeric_limits::max(); + } else if (val < WideT(std::numeric_limits::min())) { + val = std::numeric_limits::min(); + } + return Literal(int32_t(val)); +} + +template (Literal::*IntoLanes)() const> +Literal narrow(const Literal& low, const Literal& high) { + LaneArray lowLanes = (low.*IntoLanes)(); + LaneArray highLanes = (high.*IntoLanes)(); + LaneArray result; + for (size_t i = 0; i < Lanes / 2; ++i) { + result[i] = saturating_narrow(lowLanes[i].geti32()); + result[Lanes / 2 + i] = saturating_narrow(highLanes[i].geti32()); + } + return Literal(result); +} + +Literal Literal::narrowSToVecI8x16(const Literal& other) const { + return narrow<16, int8_t, &Literal::getLanesSI16x8>(*this, other); +} +Literal Literal::narrowUToVecI8x16(const Literal& other) const { + return narrow<16, uint8_t, &Literal::getLanesSI16x8>(*this, other); +} +Literal Literal::narrowSToVecI16x8(const Literal& other) const { + return narrow<8, int16_t, &Literal::getLanesI32x4>(*this, other); +} +Literal Literal::narrowUToVecI16x8(const Literal& other) const { + return narrow<8, uint16_t, &Literal::getLanesI32x4>(*this, other); +} + +enum class LaneOrder { Low, High }; + +template (Literal::*IntoLanes)() const, + LaneOrder Side> +Literal widen(const Literal& vec) { + LaneArray lanes = (vec.*IntoLanes)(); + LaneArray result; + for (size_t i = 0; i < Lanes; ++i) { + result[i] = lanes[(Side == LaneOrder::Low) ? i : i + Lanes]; + } + return Literal(result); +} + +Literal Literal::widenLowSToVecI16x8() const { + return widen<8, &Literal::getLanesSI8x16, LaneOrder::Low>(*this); +} +Literal Literal::widenHighSToVecI16x8() const { + return widen<8, &Literal::getLanesSI8x16, LaneOrder::High>(*this); +} +Literal Literal::widenLowUToVecI16x8() const { + return widen<8, &Literal::getLanesUI8x16, LaneOrder::Low>(*this); +} +Literal Literal::widenHighUToVecI16x8() const { + return widen<8, &Literal::getLanesUI8x16, LaneOrder::High>(*this); +} +Literal Literal::widenLowSToVecI32x4() const { + return widen<4, &Literal::getLanesSI16x8, LaneOrder::Low>(*this); +} +Literal Literal::widenHighSToVecI32x4() const { + return widen<4, &Literal::getLanesSI16x8, LaneOrder::High>(*this); +} +Literal Literal::widenLowUToVecI32x4() const { + return widen<4, &Literal::getLanesUI16x8, LaneOrder::Low>(*this); +} +Literal Literal::widenHighUToVecI32x4() const { + return widen<4, &Literal::getLanesUI16x8, LaneOrder::High>(*this); +} + +Literal Literal::swizzleVec8x16(const Literal& other) const { + auto lanes = getLanesUI8x16(); + auto indices = other.getLanesUI8x16(); + LaneArray<16> result; + for (size_t i = 0; i < 16; ++i) { + size_t index = indices[i].geti32(); + result[i] = index >= 16 ? Literal(int32_t(0)) : lanes[index]; + } + return Literal(result); +} + +} // namespace wasm diff --git a/binaryen/src/wasm/wasm-binary.cpp b/binaryen/src/wasm/wasm-binary.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/wasm/wasm-binary.cpp @@ -0,0 +1,5409 @@ +/* + * Copyright 2016 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +#include "ir/module-utils.h" +#include "support/bits.h" +#include "support/debug.h" +#include "wasm-binary.h" +#include "wasm-debug.h" +#include "wasm-stack.h" + +#define DEBUG_TYPE "binary" + +namespace wasm { + +void WasmBinaryWriter::prepare() { + // Collect function types and their frequencies. Collect information in each + // function in parallel, then merge. + ModuleUtils::collectSignatures(*wasm, types, typeIndices); + importInfo = wasm::make_unique(*wasm); +} + +void WasmBinaryWriter::write() { + writeHeader(); + + writeDylinkSection(); + + initializeDebugInfo(); + if (sourceMap) { + writeSourceMapProlog(); + } + + writeTypes(); + writeImports(); + writeFunctionSignatures(); + writeFunctionTableDeclaration(); + writeMemory(); + writeEvents(); + writeGlobals(); + writeExports(); + writeStart(); + writeTableElements(); + writeDataCount(); + writeFunctions(); + writeDataSegments(); + if (debugInfo) { + writeNames(); + } + if (sourceMap && !sourceMapUrl.empty()) { + writeSourceMapUrl(); + } + if (symbolMap.size() > 0) { + writeSymbolMap(); + } + + if (sourceMap) { + writeSourceMapEpilog(); + } + +#ifdef BUILD_LLVM_DWARF + // Update DWARF user sections after writing the data they refer to + // (function bodies), and before writing the user sections themselves. + if (Debug::hasDWARFSections(*wasm)) { + Debug::writeDWARFSections(*wasm, binaryLocations); + } +#endif + + writeLateUserSections(); + writeFeaturesSection(); + + finishUp(); +} + +void WasmBinaryWriter::writeHeader() { + BYN_TRACE("== writeHeader\n"); + o << int32_t(BinaryConsts::Magic); // magic number \0asm + o << int32_t(BinaryConsts::Version); +} + +int32_t WasmBinaryWriter::writeU32LEBPlaceholder() { + int32_t ret = o.size(); + o << int32_t(0); + o << int8_t(0); + return ret; +} + +void WasmBinaryWriter::writeResizableLimits( + Address initial, Address maximum, bool hasMaximum, bool shared, bool is64) { + uint32_t flags = (hasMaximum ? (uint32_t)BinaryConsts::HasMaximum : 0U) | + (shared ? (uint32_t)BinaryConsts::IsShared : 0U) | + (is64 ? (uint32_t)BinaryConsts::Is64 : 0U); + o << U32LEB(flags); + o << U32LEB(initial); + if (hasMaximum) { + o << U32LEB(maximum); + } +} + +template int32_t WasmBinaryWriter::startSection(T code) { + o << uint8_t(code); + if (sourceMap) { + sourceMapLocationsSizeAtSectionStart = sourceMapLocations.size(); + } + binaryLocationsSizeAtSectionStart = binaryLocations.expressions.size(); + return writeU32LEBPlaceholder(); // section size to be filled in later +} + +void WasmBinaryWriter::finishSection(int32_t start) { + // section size does not include the reserved bytes of the size field itself + int32_t size = o.size() - start - MaxLEB32Bytes; + auto sizeFieldSize = o.writeAt(start, U32LEB(size)); + // We can move things back if the actual LEB for the size doesn't use the + // maximum 5 bytes. In that case we need to adjust offsets after we move + // things backwards. + auto adjustmentForLEBShrinking = MaxLEB32Bytes - sizeFieldSize; + if (adjustmentForLEBShrinking) { + // we can save some room, nice + assert(sizeFieldSize < MaxLEB32Bytes); + std::move(&o[start] + MaxLEB32Bytes, + &o[start] + MaxLEB32Bytes + size, + &o[start] + sizeFieldSize); + o.resize(o.size() - adjustmentForLEBShrinking); + if (sourceMap) { + for (auto i = sourceMapLocationsSizeAtSectionStart; + i < sourceMapLocations.size(); + ++i) { + sourceMapLocations[i].first -= adjustmentForLEBShrinking; + } + } + } + + if (binaryLocationsSizeAtSectionStart != binaryLocations.expressions.size()) { + // We added the binary locations, adjust them: they must be relative + // to the code section. + assert(binaryLocationsSizeAtSectionStart == 0); + // The section type byte is right before the LEB for the size; we want + // offsets that are relative to the body, which is after that section type + // byte and the the size LEB. + auto body = start + sizeFieldSize; + // Offsets are relative to the body of the code section: after the + // section type byte and the size. + // Everything was moved by the adjustment, track that. After this, + // we are at the right absolute address. + // We are relative to the section start. + auto totalAdjustment = adjustmentForLEBShrinking + body; + for (auto& pair : binaryLocations.expressions) { + pair.second.start -= totalAdjustment; + pair.second.end -= totalAdjustment; + } + for (auto& pair : binaryLocations.functions) { + pair.second.start -= totalAdjustment; + pair.second.declarations -= totalAdjustment; + pair.second.end -= totalAdjustment; + } + for (auto& pair : binaryLocations.delimiters) { + for (auto& item : pair.second) { + item -= totalAdjustment; + } + } + } +} + +int32_t +WasmBinaryWriter::startSubsection(BinaryConsts::UserSections::Subsection code) { + return startSection(code); +} + +void WasmBinaryWriter::finishSubsection(int32_t start) { finishSection(start); } + +void WasmBinaryWriter::writeStart() { + if (!wasm->start.is()) { + return; + } + BYN_TRACE("== writeStart\n"); + auto start = startSection(BinaryConsts::Section::Start); + o << U32LEB(getFunctionIndex(wasm->start.str)); + finishSection(start); +} + +void WasmBinaryWriter::writeMemory() { + if (!wasm->memory.exists || wasm->memory.imported()) { + return; + } + BYN_TRACE("== writeMemory\n"); + auto start = startSection(BinaryConsts::Section::Memory); + o << U32LEB(1); // Define 1 memory + writeResizableLimits(wasm->memory.initial, + wasm->memory.max, + wasm->memory.hasMax(), + wasm->memory.shared, + wasm->memory.is64()); + finishSection(start); +} + +void WasmBinaryWriter::writeTypes() { + if (types.size() == 0) { + return; + } + BYN_TRACE("== writeTypes\n"); + auto start = startSection(BinaryConsts::Section::Type); + o << U32LEB(types.size()); + for (Index i = 0; i < types.size(); ++i) { + Signature& sig = types[i]; + BYN_TRACE("write " << sig.params << " -> " << sig.results << std::endl); + o << S32LEB(BinaryConsts::EncodedType::Func); + for (auto& sigType : {sig.params, sig.results}) { + o << U32LEB(sigType.size()); + for (const auto& type : sigType) { + o << binaryType(type); + } + } + } + finishSection(start); +} + +void WasmBinaryWriter::writeImports() { + auto num = importInfo->getNumImports(); + if (num == 0) { + return; + } + BYN_TRACE("== writeImports\n"); + auto start = startSection(BinaryConsts::Section::Import); + o << U32LEB(num); + auto writeImportHeader = [&](Importable* import) { + writeInlineString(import->module.str); + writeInlineString(import->base.str); + }; + ModuleUtils::iterImportedFunctions(*wasm, [&](Function* func) { + BYN_TRACE("write one function\n"); + writeImportHeader(func); + o << U32LEB(int32_t(ExternalKind::Function)); + o << U32LEB(getTypeIndex(func->sig)); + }); + ModuleUtils::iterImportedGlobals(*wasm, [&](Global* global) { + BYN_TRACE("write one global\n"); + writeImportHeader(global); + o << U32LEB(int32_t(ExternalKind::Global)); + o << binaryType(global->type); + o << U32LEB(global->mutable_); + }); + ModuleUtils::iterImportedEvents(*wasm, [&](Event* event) { + BYN_TRACE("write one event\n"); + writeImportHeader(event); + o << U32LEB(int32_t(ExternalKind::Event)); + o << U32LEB(event->attribute); + o << U32LEB(getTypeIndex(event->sig)); + }); + if (wasm->memory.imported()) { + BYN_TRACE("write one memory\n"); + writeImportHeader(&wasm->memory); + o << U32LEB(int32_t(ExternalKind::Memory)); + writeResizableLimits(wasm->memory.initial, + wasm->memory.max, + wasm->memory.hasMax(), + wasm->memory.shared, + wasm->memory.is64()); + } + if (wasm->table.imported()) { + BYN_TRACE("write one table\n"); + writeImportHeader(&wasm->table); + o << U32LEB(int32_t(ExternalKind::Table)); + o << S32LEB(BinaryConsts::EncodedType::funcref); + writeResizableLimits(wasm->table.initial, + wasm->table.max, + wasm->table.hasMax(), + /*shared=*/false, + /*is64*/ false); + } + finishSection(start); +} + +void WasmBinaryWriter::writeFunctionSignatures() { + if (importInfo->getNumDefinedFunctions() == 0) { + return; + } + BYN_TRACE("== writeFunctionSignatures\n"); + auto start = startSection(BinaryConsts::Section::Function); + o << U32LEB(importInfo->getNumDefinedFunctions()); + ModuleUtils::iterDefinedFunctions(*wasm, [&](Function* func) { + BYN_TRACE("write one\n"); + o << U32LEB(getTypeIndex(func->sig)); + }); + finishSection(start); +} + +void WasmBinaryWriter::writeExpression(Expression* curr) { + BinaryenIRToBinaryWriter(*this, o).visit(curr); +} + +void WasmBinaryWriter::writeFunctions() { + if (importInfo->getNumDefinedFunctions() == 0) { + return; + } + BYN_TRACE("== writeFunctions\n"); + auto sectionStart = startSection(BinaryConsts::Section::Code); + o << U32LEB(importInfo->getNumDefinedFunctions()); + bool DWARF = Debug::hasDWARFSections(*getModule()); + ModuleUtils::iterDefinedFunctions(*wasm, [&](Function* func) { + assert(binaryLocationTrackedExpressionsForFunc.empty()); + size_t sourceMapLocationsSizeAtFunctionStart = sourceMapLocations.size(); + BYN_TRACE("write one at" << o.size() << std::endl); + size_t sizePos = writeU32LEBPlaceholder(); + size_t start = o.size(); + BYN_TRACE("writing" << func->name << std::endl); + // Emit Stack IR if present, and if we can + if (func->stackIR && !sourceMap && !DWARF) { + BYN_TRACE("write Stack IR\n"); + StackIRToBinaryWriter(*this, o, func).write(); + } else { + BYN_TRACE("write Binaryen IR\n"); + BinaryenIRToBinaryWriter(*this, o, func, sourceMap, DWARF).write(); + } + size_t size = o.size() - start; + assert(size <= std::numeric_limits::max()); + BYN_TRACE("body size: " << size << ", writing at " << sizePos + << ", next starts at " << o.size() << "\n"); + auto sizeFieldSize = o.writeAt(sizePos, U32LEB(size)); + // We can move things back if the actual LEB for the size doesn't use the + // maximum 5 bytes. In that case we need to adjust offsets after we move + // things backwards. + auto adjustmentForLEBShrinking = MaxLEB32Bytes - sizeFieldSize; + if (adjustmentForLEBShrinking) { + // we can save some room, nice + assert(sizeFieldSize < MaxLEB32Bytes); + std::move(&o[start], &o[start] + size, &o[sizePos] + sizeFieldSize); + o.resize(o.size() - adjustmentForLEBShrinking); + if (sourceMap) { + for (auto i = sourceMapLocationsSizeAtFunctionStart; + i < sourceMapLocations.size(); + ++i) { + sourceMapLocations[i].first -= adjustmentForLEBShrinking; + } + } + for (auto* curr : binaryLocationTrackedExpressionsForFunc) { + // We added the binary locations, adjust them: they must be relative + // to the code section. + auto& span = binaryLocations.expressions[curr]; + span.start -= adjustmentForLEBShrinking; + span.end -= adjustmentForLEBShrinking; + auto iter = binaryLocations.delimiters.find(curr); + if (iter != binaryLocations.delimiters.end()) { + for (auto& item : iter->second) { + item -= adjustmentForLEBShrinking; + } + } + } + } + if (!binaryLocationTrackedExpressionsForFunc.empty()) { + binaryLocations.functions[func] = BinaryLocations::FunctionLocations{ + BinaryLocation(sizePos), + BinaryLocation(start - adjustmentForLEBShrinking), + BinaryLocation(o.size())}; + } + tableOfContents.functionBodies.emplace_back( + func->name, sizePos + sizeFieldSize, size); + binaryLocationTrackedExpressionsForFunc.clear(); + }); + finishSection(sectionStart); +} + +void WasmBinaryWriter::writeGlobals() { + if (importInfo->getNumDefinedGlobals() == 0) { + return; + } + BYN_TRACE("== writeglobals\n"); + auto start = startSection(BinaryConsts::Section::Global); + // Count and emit the total number of globals after tuple globals have been + // expanded into their constituent parts. + Index num = 0; + ModuleUtils::iterDefinedGlobals( + *wasm, [&num](Global* global) { num += global->type.size(); }); + o << U32LEB(num); + ModuleUtils::iterDefinedGlobals(*wasm, [&](Global* global) { + BYN_TRACE("write one\n"); + size_t i = 0; + for (const auto& t : global->type) { + o << binaryType(t); + o << U32LEB(global->mutable_); + if (global->type.size() == 1) { + writeExpression(global->init); + } else { + writeExpression(global->init->cast()->operands[i]); + } + o << int8_t(BinaryConsts::End); + ++i; + } + }); + finishSection(start); +} + +void WasmBinaryWriter::writeExports() { + if (wasm->exports.size() == 0) { + return; + } + BYN_TRACE("== writeexports\n"); + auto start = startSection(BinaryConsts::Section::Export); + o << U32LEB(wasm->exports.size()); + for (auto& curr : wasm->exports) { + BYN_TRACE("write one\n"); + writeInlineString(curr->name.str); + o << U32LEB(int32_t(curr->kind)); + switch (curr->kind) { + case ExternalKind::Function: + o << U32LEB(getFunctionIndex(curr->value)); + break; + case ExternalKind::Table: + o << U32LEB(0); + break; + case ExternalKind::Memory: + o << U32LEB(0); + break; + case ExternalKind::Global: + o << U32LEB(getGlobalIndex(curr->value)); + break; + case ExternalKind::Event: + o << U32LEB(getEventIndex(curr->value)); + break; + default: + WASM_UNREACHABLE("unexpected extern kind"); + } + } + finishSection(start); +} + +void WasmBinaryWriter::writeDataCount() { + if (!wasm->features.hasBulkMemory() || !wasm->memory.segments.size()) { + return; + } + auto start = startSection(BinaryConsts::Section::DataCount); + o << U32LEB(wasm->memory.segments.size()); + finishSection(start); +} + +void WasmBinaryWriter::writeDataSegments() { + if (wasm->memory.segments.size() == 0) { + return; + } + if (wasm->memory.segments.size() > WebLimitations::MaxDataSegments) { + std::cerr << "Some VMs may not accept this binary because it has a large " + << "number of data segments. Run the limit-segments pass to " + << "merge segments.\n"; + } + auto start = startSection(BinaryConsts::Section::Data); + o << U32LEB(wasm->memory.segments.size()); + for (auto& segment : wasm->memory.segments) { + uint32_t flags = 0; + if (segment.isPassive) { + flags |= BinaryConsts::IsPassive; + } + o << U32LEB(flags); + if (!segment.isPassive) { + writeExpression(segment.offset); + o << int8_t(BinaryConsts::End); + } + writeInlineBuffer(segment.data.data(), segment.data.size()); + } + finishSection(start); +} + +uint32_t WasmBinaryWriter::getFunctionIndex(Name name) const { + auto it = indexes.functionIndexes.find(name); + assert(it != indexes.functionIndexes.end()); + return it->second; +} + +uint32_t WasmBinaryWriter::getGlobalIndex(Name name) const { + auto it = indexes.globalIndexes.find(name); + assert(it != indexes.globalIndexes.end()); + return it->second; +} + +uint32_t WasmBinaryWriter::getEventIndex(Name name) const { + auto it = indexes.eventIndexes.find(name); + assert(it != indexes.eventIndexes.end()); + return it->second; +} + +uint32_t WasmBinaryWriter::getTypeIndex(Signature sig) const { + auto it = typeIndices.find(sig); + assert(it != typeIndices.end()); + return it->second; +} + +void WasmBinaryWriter::writeFunctionTableDeclaration() { + if (!wasm->table.exists || wasm->table.imported()) { + return; + } + BYN_TRACE("== writeFunctionTableDeclaration\n"); + auto start = startSection(BinaryConsts::Section::Table); + o << U32LEB(1); // Declare 1 table. + o << S32LEB(BinaryConsts::EncodedType::funcref); + writeResizableLimits(wasm->table.initial, + wasm->table.max, + wasm->table.hasMax(), + /*shared=*/false, + /*is64*/ false); + finishSection(start); +} + +void WasmBinaryWriter::writeTableElements() { + if (!wasm->table.exists || wasm->table.segments.size() == 0) { + return; + } + BYN_TRACE("== writeTableElements\n"); + auto start = startSection(BinaryConsts::Section::Element); + + o << U32LEB(wasm->table.segments.size()); + for (auto& segment : wasm->table.segments) { + // Table index; 0 in the MVP (and binaryen IR only has 1 table) + o << U32LEB(0); + writeExpression(segment.offset); + o << int8_t(BinaryConsts::End); + o << U32LEB(segment.data.size()); + for (auto name : segment.data) { + o << U32LEB(getFunctionIndex(name)); + } + } + finishSection(start); +} + +void WasmBinaryWriter::writeEvents() { + if (importInfo->getNumDefinedEvents() == 0) { + return; + } + BYN_TRACE("== writeEvents\n"); + auto start = startSection(BinaryConsts::Section::Event); + auto num = importInfo->getNumDefinedEvents(); + o << U32LEB(num); + ModuleUtils::iterDefinedEvents(*wasm, [&](Event* event) { + BYN_TRACE("write one\n"); + o << U32LEB(event->attribute); + o << U32LEB(getTypeIndex(event->sig)); + }); + + finishSection(start); +} + +void WasmBinaryWriter::writeNames() { + BYN_TRACE("== writeNames\n"); + auto start = startSection(BinaryConsts::Section::User); + writeInlineString(BinaryConsts::UserSections::Name); + + // module name + if (wasm->name.is()) { + auto substart = + startSubsection(BinaryConsts::UserSections::Subsection::NameModule); + writeEscapedName(wasm->name.str); + finishSubsection(substart); + } + + // function names + { + auto substart = + startSubsection(BinaryConsts::UserSections::Subsection::NameFunction); + o << U32LEB(indexes.functionIndexes.size()); + Index emitted = 0; + auto add = [&](Function* curr) { + o << U32LEB(emitted); + writeEscapedName(curr->name.str); + emitted++; + }; + ModuleUtils::iterImportedFunctions(*wasm, add); + ModuleUtils::iterDefinedFunctions(*wasm, add); + assert(emitted == indexes.functionIndexes.size()); + finishSubsection(substart); + } + + // local names + { + // Find all functions with at least one local name and only emit the + // subsection if there is at least one. + std::vector> functionsWithLocalNames; + Index checked = 0; + auto check = [&](Function* curr) { + auto numLocals = curr->getNumLocals(); + for (Index i = 0; i < numLocals; ++i) { + if (curr->hasLocalName(i)) { + functionsWithLocalNames.push_back({checked, curr}); + break; + } + } + checked++; + }; + ModuleUtils::iterImportedFunctions(*wasm, check); + ModuleUtils::iterDefinedFunctions(*wasm, check); + assert(checked == indexes.functionIndexes.size()); + if (functionsWithLocalNames.size() > 0) { + // Otherwise emit those functions but only include locals with a name. + auto substart = + startSubsection(BinaryConsts::UserSections::Subsection::NameLocal); + o << U32LEB(functionsWithLocalNames.size()); + Index emitted = 0; + for (auto& indexedFunc : functionsWithLocalNames) { + std::vector> localsWithNames; + auto numLocals = indexedFunc.second->getNumLocals(); + for (Index i = 0; i < numLocals; ++i) { + if (indexedFunc.second->hasLocalName(i)) { + localsWithNames.push_back({i, indexedFunc.second->getLocalName(i)}); + } + } + assert(localsWithNames.size()); + o << U32LEB(indexedFunc.first); + o << U32LEB(localsWithNames.size()); + for (auto& indexedLocal : localsWithNames) { + o << U32LEB(indexedLocal.first); + writeEscapedName(indexedLocal.second.str); + } + emitted++; + } + assert(emitted == functionsWithLocalNames.size()); + finishSubsection(substart); + } + } + + // table names + if (wasm->table.exists && wasm->table.name.is()) { + auto substart = + startSubsection(BinaryConsts::UserSections::Subsection::NameTable); + o << U32LEB(1) << U32LEB(0); // currently exactly 1 table at index 0 + writeEscapedName(wasm->table.name.str); + finishSubsection(substart); + } + + // memory names + if (wasm->memory.exists && wasm->memory.name.is()) { + auto substart = + startSubsection(BinaryConsts::UserSections::Subsection::NameMemory); + o << U32LEB(1) << U32LEB(0); // currently exactly 1 memory at index 0 + writeEscapedName(wasm->memory.name.str); + finishSubsection(substart); + } + + // global names + { + std::vector> globalsWithNames; + Index checked = 0; + auto check = [&](Global* curr) { + if (curr->name.is()) { + globalsWithNames.push_back({checked, curr}); + } + checked++; + }; + ModuleUtils::iterImportedGlobals(*wasm, check); + ModuleUtils::iterDefinedGlobals(*wasm, check); + assert(checked == indexes.globalIndexes.size()); + if (globalsWithNames.size() > 0) { + auto substart = + startSubsection(BinaryConsts::UserSections::Subsection::NameGlobal); + o << U32LEB(globalsWithNames.size()); + for (auto& indexedGlobal : globalsWithNames) { + o << U32LEB(indexedGlobal.first); + writeEscapedName(indexedGlobal.second->name.str); + } + finishSubsection(substart); + } + } + + // TODO: label, type, element and data names + // see: https://github.com/WebAssembly/extended-name-section + + finishSection(start); +} + +void WasmBinaryWriter::writeSourceMapUrl() { + BYN_TRACE("== writeSourceMapUrl\n"); + auto start = startSection(BinaryConsts::Section::User); + writeInlineString(BinaryConsts::UserSections::SourceMapUrl); + writeInlineString(sourceMapUrl.c_str()); + finishSection(start); +} + +void WasmBinaryWriter::writeSymbolMap() { + std::ofstream file(symbolMap); + auto write = [&](Function* func) { + file << getFunctionIndex(func->name) << ":" << func->name.str << std::endl; + }; + ModuleUtils::iterImportedFunctions(*wasm, write); + ModuleUtils::iterDefinedFunctions(*wasm, write); + file.close(); +} + +void WasmBinaryWriter::initializeDebugInfo() { + lastDebugLocation = {0, /* lineNumber = */ 1, 0}; +} + +void WasmBinaryWriter::writeSourceMapProlog() { + *sourceMap << "{\"version\":3,\"sources\":["; + for (size_t i = 0; i < wasm->debugInfoFileNames.size(); i++) { + if (i > 0) { + *sourceMap << ","; + } + // TODO respect JSON string encoding, e.g. quotes and control chars. + *sourceMap << "\"" << wasm->debugInfoFileNames[i] << "\""; + } + *sourceMap << "],\"names\":[],\"mappings\":\""; +} + +static void writeBase64VLQ(std::ostream& out, int32_t n) { + uint32_t value = n >= 0 ? n << 1 : ((-n) << 1) | 1; + while (1) { + uint32_t digit = value & 0x1F; + value >>= 5; + if (!value) { + // last VLQ digit -- base64 codes 'A'..'Z', 'a'..'f' + out << char(digit < 26 ? 'A' + digit : 'a' + digit - 26); + break; + } + // more VLG digit will follow -- add continuation bit (0x20), + // base64 codes 'g'..'z', '0'..'9', '+', '/' + out << char(digit < 20 + ? 'g' + digit + : digit < 30 ? '0' + digit - 20 : digit == 30 ? '+' : '/'); + } +} + +void WasmBinaryWriter::writeSourceMapEpilog() { + // write source map entries + size_t lastOffset = 0; + Function::DebugLocation lastLoc = {0, /* lineNumber = */ 1, 0}; + for (const auto& offsetAndlocPair : sourceMapLocations) { + if (lastOffset > 0) { + *sourceMap << ","; + } + size_t offset = offsetAndlocPair.first; + const Function::DebugLocation& loc = *offsetAndlocPair.second; + writeBase64VLQ(*sourceMap, int32_t(offset - lastOffset)); + writeBase64VLQ(*sourceMap, int32_t(loc.fileIndex - lastLoc.fileIndex)); + writeBase64VLQ(*sourceMap, int32_t(loc.lineNumber - lastLoc.lineNumber)); + writeBase64VLQ(*sourceMap, + int32_t(loc.columnNumber - lastLoc.columnNumber)); + lastLoc = loc; + lastOffset = offset; + } + *sourceMap << "\"}"; +} + +void WasmBinaryWriter::writeLateUserSections() { + for (auto& section : wasm->userSections) { + if (section.name != BinaryConsts::UserSections::Dylink) { + writeUserSection(section); + } + } +} + +void WasmBinaryWriter::writeUserSection(const UserSection& section) { + auto start = startSection(BinaryConsts::User); + writeInlineString(section.name.c_str()); + for (size_t i = 0; i < section.data.size(); i++) { + o << uint8_t(section.data[i]); + } + finishSection(start); +} + +void WasmBinaryWriter::writeFeaturesSection() { + if (!wasm->hasFeaturesSection || wasm->features.isMVP()) { + return; + } + + // TODO(tlively): unify feature names with rest of toolchain and use + // FeatureSet::toString() + auto toString = [](FeatureSet::Feature f) { + switch (f) { + case FeatureSet::Atomics: + return BinaryConsts::UserSections::AtomicsFeature; + case FeatureSet::MutableGlobals: + return BinaryConsts::UserSections::MutableGlobalsFeature; + case FeatureSet::TruncSat: + return BinaryConsts::UserSections::TruncSatFeature; + case FeatureSet::SIMD: + return BinaryConsts::UserSections::SIMD128Feature; + case FeatureSet::BulkMemory: + return BinaryConsts::UserSections::BulkMemoryFeature; + case FeatureSet::SignExt: + return BinaryConsts::UserSections::SignExtFeature; + case FeatureSet::ExceptionHandling: + return BinaryConsts::UserSections::ExceptionHandlingFeature; + case FeatureSet::TailCall: + return BinaryConsts::UserSections::TailCallFeature; + case FeatureSet::ReferenceTypes: + return BinaryConsts::UserSections::ReferenceTypesFeature; + case FeatureSet::Multivalue: + return BinaryConsts::UserSections::MultivalueFeature; + case FeatureSet::GC: + return BinaryConsts::UserSections::GCFeature; + case FeatureSet::Memory64: + return BinaryConsts::UserSections::Memory64Feature; + default: + WASM_UNREACHABLE("unexpected feature flag"); + } + }; + + std::vector features; + wasm->features.iterFeatures( + [&](FeatureSet::Feature f) { features.push_back(toString(f)); }); + + auto start = startSection(BinaryConsts::User); + writeInlineString(BinaryConsts::UserSections::TargetFeatures); + o << U32LEB(features.size()); + for (auto& f : features) { + o << uint8_t(BinaryConsts::FeatureUsed); + writeInlineString(f); + } + finishSection(start); +} + +void WasmBinaryWriter::writeDylinkSection() { + if (!wasm->dylinkSection) { + return; + } + + auto start = startSection(BinaryConsts::User); + writeInlineString(BinaryConsts::UserSections::Dylink); + o << U32LEB(wasm->dylinkSection->memorySize); + o << U32LEB(wasm->dylinkSection->memoryAlignment); + o << U32LEB(wasm->dylinkSection->tableSize); + o << U32LEB(wasm->dylinkSection->tableAlignment); + o << U32LEB(wasm->dylinkSection->neededDynlibs.size()); + for (auto& neededDynlib : wasm->dylinkSection->neededDynlibs) { + writeInlineString(neededDynlib.c_str()); + } + finishSection(start); +} + +void WasmBinaryWriter::writeDebugLocation(const Function::DebugLocation& loc) { + if (loc == lastDebugLocation) { + return; + } + auto offset = o.size(); + sourceMapLocations.emplace_back(offset, &loc); + lastDebugLocation = loc; +} + +void WasmBinaryWriter::writeDebugLocation(Expression* curr, Function* func) { + if (sourceMap) { + auto& debugLocations = func->debugLocations; + auto iter = debugLocations.find(curr); + if (iter != debugLocations.end()) { + writeDebugLocation(iter->second); + } + } + // If this is an instruction in a function, and if the original wasm had + // binary locations tracked, then track it in the output as well. + if (func && !func->expressionLocations.empty()) { + binaryLocations.expressions[curr] = + BinaryLocations::Span{BinaryLocation(o.size()), 0}; + binaryLocationTrackedExpressionsForFunc.push_back(curr); + } +} + +void WasmBinaryWriter::writeDebugLocationEnd(Expression* curr, Function* func) { + if (func && !func->expressionLocations.empty()) { + auto& span = binaryLocations.expressions.at(curr); + assert(span.end == 0); + span.end = o.size(); + } +} + +void WasmBinaryWriter::writeExtraDebugLocation( + Expression* curr, Function* func, BinaryLocations::DelimiterId id) { + if (func && !func->expressionLocations.empty()) { + binaryLocations.delimiters[curr][id] = o.size(); + } +} + +void WasmBinaryWriter::writeInlineString(const char* name) { + int32_t size = strlen(name); + o << U32LEB(size); + for (int32_t i = 0; i < size; i++) { + o << int8_t(name[i]); + } +} + +static bool isHexDigit(char ch) { + return (ch >= '0' && ch <= '9') || (ch >= 'a' && ch <= 'f') || + (ch >= 'A' && ch <= 'F'); +} + +static int decodeHexNibble(char ch) { + return ch <= '9' ? ch & 15 : (ch & 15) + 9; +} + +void WasmBinaryWriter::writeEscapedName(const char* name) { + if (!strpbrk(name, "\\")) { + writeInlineString(name); + return; + } + // decode escaped by escapeName (see below) function names + std::string unescaped; + int32_t size = strlen(name); + for (int32_t i = 0; i < size;) { + char ch = name[i++]; + // support only `\xx` escapes; ignore invalid or unsupported escapes + if (ch != '\\' || i + 1 >= size || !isHexDigit(name[i]) || + !isHexDigit(name[i + 1])) { + unescaped.push_back(ch); + continue; + } + unescaped.push_back( + char((decodeHexNibble(name[i]) << 4) | decodeHexNibble(name[i + 1]))); + i += 2; + } + writeInlineString(unescaped.c_str()); +} + +void WasmBinaryWriter::writeInlineBuffer(const char* data, size_t size) { + o << U32LEB(size); + for (size_t i = 0; i < size; i++) { + o << int8_t(data[i]); + } +} + +void WasmBinaryWriter::emitBuffer(const char* data, size_t size) { + assert(size > 0); + buffersToWrite.emplace_back(data, size, o.size()); + // placeholder, we'll fill in the pointer to the buffer later when we have it + o << uint32_t(0); +} + +void WasmBinaryWriter::emitString(const char* str) { + BYN_TRACE("emitString " << str << std::endl); + emitBuffer(str, strlen(str) + 1); +} + +void WasmBinaryWriter::finishUp() { + BYN_TRACE("finishUp\n"); + // finish buffers + for (const auto& buffer : buffersToWrite) { + BYN_TRACE("writing buffer" + << (int)buffer.data[0] << "," << (int)buffer.data[1] << " at " + << o.size() << " and pointer is at " << buffer.pointerLocation + << "\n"); + o.writeAt(buffer.pointerLocation, (uint32_t)o.size()); + for (size_t i = 0; i < buffer.size; i++) { + o << (uint8_t)buffer.data[i]; + } + } +} + +// reader + +bool WasmBinaryBuilder::hasDWARFSections() { + assert(pos == 0); + getInt32(); // magic + getInt32(); // version + bool has = false; + while (more()) { + uint8_t sectionCode = getInt8(); + uint32_t payloadLen = getU32LEB(); + if (uint64_t(pos) + uint64_t(payloadLen) > input.size()) { + throwError("Section extends beyond end of input"); + } + auto oldPos = pos; + if (sectionCode == BinaryConsts::Section::User) { + auto sectionName = getInlineString(); + if (Debug::isDWARFSection(sectionName)) { + has = true; + break; + } + } + pos = oldPos + payloadLen; + } + pos = 0; + return has; +} + +void WasmBinaryBuilder::read() { + if (DWARF) { + // In order to update dwarf, we must store info about each IR node's + // binary position. This has noticeable memory overhead, so we don't do it + // by default: the user must request it by setting "DWARF", and even if so + // we scan ahead to see that there actually *are* DWARF sections, so that + // we don't do unnecessary work. + if (!hasDWARFSections()) { + DWARF = false; + } + } + + readHeader(); + readSourceMapHeader(); + + // read sections until the end + while (more()) { + uint8_t sectionCode = getInt8(); + uint32_t payloadLen = getU32LEB(); + if (uint64_t(pos) + uint64_t(payloadLen) > input.size()) { + throwError("Section extends beyond end of input"); + } + + auto oldPos = pos; + + // note the section in the list of seen sections, as almost no sections can + // appear more than once, and verify those that shouldn't do not. + if (sectionCode != BinaryConsts::Section::User && + sectionCode != BinaryConsts::Section::Code) { + if (!seenSections.insert(BinaryConsts::Section(sectionCode)).second) { + throwError("section seen more than once: " + + std::to_string(sectionCode)); + } + } + + switch (sectionCode) { + case BinaryConsts::Section::Start: + readStart(); + break; + case BinaryConsts::Section::Memory: + readMemory(); + break; + case BinaryConsts::Section::Type: + readSignatures(); + break; + case BinaryConsts::Section::Import: + readImports(); + break; + case BinaryConsts::Section::Function: + readFunctionSignatures(); + break; + case BinaryConsts::Section::Code: + if (DWARF) { + codeSectionLocation = pos; + } + readFunctions(); + break; + case BinaryConsts::Section::Export: + readExports(); + break; + case BinaryConsts::Section::Element: + readTableElements(); + break; + case BinaryConsts::Section::Global: + readGlobals(); + break; + case BinaryConsts::Section::Data: + readDataSegments(); + break; + case BinaryConsts::Section::DataCount: + readDataCount(); + break; + case BinaryConsts::Section::Table: + readFunctionTableDeclaration(); + break; + case BinaryConsts::Section::Event: + readEvents(); + break; + default: { + readUserSection(payloadLen); + if (pos > oldPos + payloadLen) { + throwError("bad user section size, started at " + + std::to_string(oldPos) + " plus payload " + + std::to_string(payloadLen) + + " not being equal to new position " + std::to_string(pos)); + } + pos = oldPos + payloadLen; + } + } + + // make sure we advanced exactly past this section + if (pos != oldPos + payloadLen) { + throwError("bad section size, started at " + std::to_string(oldPos) + + " plus payload " + std::to_string(payloadLen) + + " not being equal to new position " + std::to_string(pos)); + } + } + + validateBinary(); + processNames(); +} + +void WasmBinaryBuilder::readUserSection(size_t payloadLen) { + auto oldPos = pos; + Name sectionName = getInlineString(); + size_t read = pos - oldPos; + if (read > payloadLen) { + throwError("bad user section size"); + } + payloadLen -= read; + if (sectionName.equals(BinaryConsts::UserSections::Name)) { + readNames(payloadLen); + } else if (sectionName.equals(BinaryConsts::UserSections::TargetFeatures)) { + readFeatures(payloadLen); + } else if (sectionName.equals(BinaryConsts::UserSections::Dylink)) { + readDylink(payloadLen); + } else { + // an unfamiliar custom section + if (sectionName.equals(BinaryConsts::UserSections::Linking)) { + std::cerr + << "warning: linking section is present, so this is not a standard " + "wasm file - binaryen cannot handle this properly!\n"; + } + wasm.userSections.resize(wasm.userSections.size() + 1); + auto& section = wasm.userSections.back(); + section.name = sectionName.str; + auto sectionSize = payloadLen; + section.data.resize(sectionSize); + for (size_t i = 0; i < sectionSize; i++) { + section.data[i] = getInt8(); + } + } +} + +uint8_t WasmBinaryBuilder::getInt8() { + if (!more()) { + throwError("unexpected end of input"); + } + BYN_TRACE("getInt8: " << (int)(uint8_t)input[pos] << " (at " << pos << ")\n"); + return input[pos++]; +} + +uint16_t WasmBinaryBuilder::getInt16() { + BYN_TRACE("<==\n"); + auto ret = uint16_t(getInt8()); + ret |= uint16_t(getInt8()) << 8; + BYN_TRACE("getInt16: " << ret << "/0x" << std::hex << ret << std::dec + << " ==>\n"); + return ret; +} + +uint32_t WasmBinaryBuilder::getInt32() { + BYN_TRACE("<==\n"); + auto ret = uint32_t(getInt16()); + ret |= uint32_t(getInt16()) << 16; + BYN_TRACE("getInt32: " << ret << "/0x" << std::hex << ret << std::dec + << " ==>\n"); + return ret; +} + +uint64_t WasmBinaryBuilder::getInt64() { + BYN_TRACE("<==\n"); + auto ret = uint64_t(getInt32()); + ret |= uint64_t(getInt32()) << 32; + BYN_TRACE("getInt64: " << ret << "/0x" << std::hex << ret << std::dec + << " ==>\n"); + return ret; +} + +uint8_t WasmBinaryBuilder::getLaneIndex(size_t lanes) { + BYN_TRACE("<==\n"); + auto ret = getInt8(); + if (ret >= lanes) { + throwError("Illegal lane index"); + } + BYN_TRACE("getLaneIndex(" << lanes << "): " << ret << " ==>" << std::endl); + return ret; +} + +Literal WasmBinaryBuilder::getFloat32Literal() { + BYN_TRACE("<==\n"); + auto ret = Literal(getInt32()); + ret = ret.castToF32(); + BYN_TRACE("getFloat32: " << ret << " ==>\n"); + return ret; +} + +Literal WasmBinaryBuilder::getFloat64Literal() { + BYN_TRACE("<==\n"); + auto ret = Literal(getInt64()); + ret = ret.castToF64(); + BYN_TRACE("getFloat64: " << ret << " ==>\n"); + return ret; +} + +Literal WasmBinaryBuilder::getVec128Literal() { + BYN_TRACE("<==\n"); + std::array bytes; + for (auto i = 0; i < 16; ++i) { + bytes[i] = getInt8(); + } + auto ret = Literal(bytes.data()); + BYN_TRACE("getVec128: " << ret << " ==>\n"); + return ret; +} + +uint32_t WasmBinaryBuilder::getU32LEB() { + BYN_TRACE("<==\n"); + U32LEB ret; + ret.read([&]() { return getInt8(); }); + BYN_TRACE("getU32LEB: " << ret.value << " ==>\n"); + return ret.value; +} + +uint64_t WasmBinaryBuilder::getU64LEB() { + BYN_TRACE("<==\n"); + U64LEB ret; + ret.read([&]() { return getInt8(); }); + BYN_TRACE("getU64LEB: " << ret.value << " ==>\n"); + return ret.value; +} + +int32_t WasmBinaryBuilder::getS32LEB() { + BYN_TRACE("<==\n"); + S32LEB ret; + ret.read([&]() { return (int8_t)getInt8(); }); + BYN_TRACE("getS32LEB: " << ret.value << " ==>\n"); + return ret.value; +} + +int64_t WasmBinaryBuilder::getS64LEB() { + BYN_TRACE("<==\n"); + S64LEB ret; + ret.read([&]() { return (int8_t)getInt8(); }); + BYN_TRACE("getS64LEB: " << ret.value << " ==>\n"); + return ret.value; +} + +Type WasmBinaryBuilder::getType() { + int type = getS32LEB(); + // Single value types are negative; signature indices are non-negative + if (type >= 0) { + // TODO: Handle block input types properly + if (size_t(type) >= signatures.size()) { + throwError("invalid signature index: " + std::to_string(type)); + } + return signatures[type].results; + } + switch (type) { + // None only used for block signatures. TODO: Separate out? + case BinaryConsts::EncodedType::Empty: + return Type::none; + case BinaryConsts::EncodedType::i32: + return Type::i32; + case BinaryConsts::EncodedType::i64: + return Type::i64; + case BinaryConsts::EncodedType::f32: + return Type::f32; + case BinaryConsts::EncodedType::f64: + return Type::f64; + case BinaryConsts::EncodedType::v128: + return Type::v128; + case BinaryConsts::EncodedType::funcref: + return Type::funcref; + case BinaryConsts::EncodedType::externref: + return Type::externref; + case BinaryConsts::EncodedType::exnref: + return Type::exnref; + case BinaryConsts::EncodedType::anyref: + return Type::anyref; + case BinaryConsts::EncodedType::eqref: + return Type::eqref; + case BinaryConsts::EncodedType::i31ref: + return Type::i31ref; + default: + throwError("invalid wasm type: " + std::to_string(type)); + } + WASM_UNREACHABLE("unexpected type"); +} + +HeapType WasmBinaryBuilder::getHeapType() { + int type = getS32LEB(); // TODO: Actually encoded as s33 + // Single heap types are negative; heap type indices are non-negative + if (type >= 0) { + if (size_t(type) >= signatures.size()) { + throwError("invalid signature index: " + std::to_string(type)); + } + return HeapType(signatures[type]); + } + switch (type) { + case BinaryConsts::EncodedHeapType::func: + return HeapType::FuncKind; + case BinaryConsts::EncodedHeapType::extern_: + return HeapType::ExternKind; + case BinaryConsts::EncodedHeapType::exn: + return HeapType::ExnKind; + case BinaryConsts::EncodedHeapType::any: + return HeapType::AnyKind; + case BinaryConsts::EncodedHeapType::eq: + return HeapType::EqKind; + case BinaryConsts::EncodedHeapType::i31: + return HeapType::I31Kind; + default: + throwError("invalid wasm heap type: " + std::to_string(type)); + } + WASM_UNREACHABLE("unexpected type"); +} + +Type WasmBinaryBuilder::getConcreteType() { + auto type = getType(); + if (!type.isConcrete()) { + throw ParseException("non-concrete type when one expected"); + } + return type; +} + +Name WasmBinaryBuilder::getInlineString() { + BYN_TRACE("<==\n"); + auto len = getU32LEB(); + std::string str; + for (size_t i = 0; i < len; i++) { + auto curr = char(getInt8()); + if (curr == 0) { + throwError( + "inline string contains NULL (0). that is technically valid in wasm, " + "but you shouldn't do it, and it's not supported in binaryen"); + } + str = str + curr; + } + BYN_TRACE("getInlineString: " << str << " ==>\n"); + return Name(str); +} + +void WasmBinaryBuilder::verifyInt8(int8_t x) { + int8_t y = getInt8(); + if (x != y) { + throwError("surprising value"); + } +} + +void WasmBinaryBuilder::verifyInt16(int16_t x) { + int16_t y = getInt16(); + if (x != y) { + throwError("surprising value"); + } +} + +void WasmBinaryBuilder::verifyInt32(int32_t x) { + int32_t y = getInt32(); + if (x != y) { + throwError("surprising value"); + } +} + +void WasmBinaryBuilder::verifyInt64(int64_t x) { + int64_t y = getInt64(); + if (x != y) { + throwError("surprising value"); + } +} + +void WasmBinaryBuilder::ungetInt8() { + assert(pos > 0); + BYN_TRACE("ungetInt8 (at " << pos << ")\n"); + pos--; +} + +void WasmBinaryBuilder::readHeader() { + BYN_TRACE("== readHeader\n"); + verifyInt32(BinaryConsts::Magic); + verifyInt32(BinaryConsts::Version); +} + +void WasmBinaryBuilder::readStart() { + BYN_TRACE("== readStart\n"); + startIndex = getU32LEB(); +} + +void WasmBinaryBuilder::readMemory() { + BYN_TRACE("== readMemory\n"); + auto numMemories = getU32LEB(); + if (!numMemories) { + return; + } + if (numMemories != 1) { + throwError("Must be exactly 1 memory"); + } + if (wasm.memory.exists) { + throwError("Memory cannot be both imported and defined"); + } + wasm.memory.exists = true; + getResizableLimits(wasm.memory.initial, + wasm.memory.max, + wasm.memory.shared, + wasm.memory.indexType, + Memory::kUnlimitedSize); +} + +void WasmBinaryBuilder::readSignatures() { + BYN_TRACE("== readSignatures\n"); + size_t numTypes = getU32LEB(); + BYN_TRACE("num: " << numTypes << std::endl); + for (size_t i = 0; i < numTypes; i++) { + BYN_TRACE("read one\n"); + std::vector params; + std::vector results; + auto form = getS32LEB(); + if (form != BinaryConsts::EncodedType::Func) { + throwError("bad signature form " + std::to_string(form)); + } + size_t numParams = getU32LEB(); + BYN_TRACE("num params: " << numParams << std::endl); + for (size_t j = 0; j < numParams; j++) { + params.push_back(getConcreteType()); + } + auto numResults = getU32LEB(); + BYN_TRACE("num results: " << numResults << std::endl); + for (size_t j = 0; j < numResults; j++) { + results.push_back(getConcreteType()); + } + signatures.emplace_back(Type(params), Type(results)); + } +} + +Name WasmBinaryBuilder::getFunctionName(Index index) { + if (index >= wasm.functions.size()) { + throwError("invalid function index"); + } + return wasm.functions[index]->name; +} + +Name WasmBinaryBuilder::getGlobalName(Index index) { + if (index >= wasm.globals.size()) { + throwError("invalid global index"); + } + return wasm.globals[index]->name; +} + +Name WasmBinaryBuilder::getEventName(Index index) { + if (index >= wasm.events.size()) { + throwError("invalid event index"); + } + return wasm.events[index]->name; +} + +void WasmBinaryBuilder::getResizableLimits(Address& initial, + Address& max, + bool& shared, + Type& indexType, + Address defaultIfNoMax) { + auto flags = getU32LEB(); + initial = getU32LEB(); + bool hasMax = (flags & BinaryConsts::HasMaximum) != 0; + bool isShared = (flags & BinaryConsts::IsShared) != 0; + bool is64 = (flags & BinaryConsts::Is64) != 0; + if (isShared && !hasMax) { + throwError("shared memory must have max size"); + } + shared = isShared; + indexType = is64 ? Type::i64 : Type::i32; + if (hasMax) { + max = getU32LEB(); + } else { + max = defaultIfNoMax; + } +} + +void WasmBinaryBuilder::readImports() { + BYN_TRACE("== readImports\n"); + size_t num = getU32LEB(); + BYN_TRACE("num: " << num << std::endl); + Builder builder(wasm); + for (size_t i = 0; i < num; i++) { + BYN_TRACE("read one\n"); + auto module = getInlineString(); + auto base = getInlineString(); + auto kind = (ExternalKind)getU32LEB(); + // We set a unique prefix for the name based on the kind. This ensures no + // collisions between them, which can't occur here (due to the index i) but + // could occur later due to the names section. + switch (kind) { + case ExternalKind::Function: { + auto name = Name(std::string("fimport$") + std::to_string(i)); + auto index = getU32LEB(); + if (index >= signatures.size()) { + throwError("invalid function index " + std::to_string(index) + " / " + + std::to_string(signatures.size())); + } + auto* curr = builder.makeFunction(name, signatures[index], {}); + curr->module = module; + curr->base = base; + wasm.addFunction(curr); + functionImports.push_back(curr); + break; + } + case ExternalKind::Table: { + wasm.table.module = module; + wasm.table.base = base; + wasm.table.name = Name(std::string("timport$") + std::to_string(i)); + auto elementType = getS32LEB(); + WASM_UNUSED(elementType); + if (elementType != BinaryConsts::EncodedType::funcref) { + throwError("Imported table type is not funcref"); + } + wasm.table.exists = true; + bool is_shared; + Type indexType; + getResizableLimits(wasm.table.initial, + wasm.table.max, + is_shared, + indexType, + Table::kUnlimitedSize); + if (is_shared) { + throwError("Tables may not be shared"); + } + if (indexType == Type::i64) { + throwError("Tables may not be 64-bit"); + } + break; + } + case ExternalKind::Memory: { + wasm.memory.module = module; + wasm.memory.base = base; + wasm.memory.name = Name(std::string("mimport$") + std::to_string(i)); + wasm.memory.exists = true; + getResizableLimits(wasm.memory.initial, + wasm.memory.max, + wasm.memory.shared, + wasm.memory.indexType, + Memory::kUnlimitedSize); + break; + } + case ExternalKind::Global: { + auto name = Name(std::string("gimport$") + std::to_string(i)); + auto type = getConcreteType(); + auto mutable_ = getU32LEB(); + auto* curr = + builder.makeGlobal(name, + type, + nullptr, + mutable_ ? Builder::Mutable : Builder::Immutable); + curr->module = module; + curr->base = base; + wasm.addGlobal(curr); + globalImports.push_back(curr); + break; + } + case ExternalKind::Event: { + auto name = Name(std::string("eimport$") + std::to_string(i)); + auto attribute = getU32LEB(); + auto index = getU32LEB(); + if (index >= signatures.size()) { + throwError("invalid event index " + std::to_string(index) + " / " + + std::to_string(signatures.size())); + } + auto* curr = builder.makeEvent(name, attribute, signatures[index]); + curr->module = module; + curr->base = base; + wasm.addEvent(curr); + break; + } + default: { + throwError("bad import kind"); + } + } + } +} + +Name WasmBinaryBuilder::getNextLabel() { + requireFunctionContext("getting a label"); + return Name("label$" + std::to_string(nextLabel++)); +} + +void WasmBinaryBuilder::requireFunctionContext(const char* error) { + if (!currFunction) { + throwError(std::string("in a non-function context: ") + error); + } +} + +void WasmBinaryBuilder::readFunctionSignatures() { + BYN_TRACE("== readFunctionSignatures\n"); + size_t num = getU32LEB(); + BYN_TRACE("num: " << num << std::endl); + for (size_t i = 0; i < num; i++) { + BYN_TRACE("read one\n"); + auto index = getU32LEB(); + if (index >= signatures.size()) { + throwError("invalid function type index for function"); + } + functionSignatures.push_back(signatures[index]); + } +} + +void WasmBinaryBuilder::readFunctions() { + BYN_TRACE("== readFunctions\n"); + size_t total = getU32LEB(); + if (total != functionSignatures.size()) { + throwError("invalid function section size, must equal types"); + } + for (size_t i = 0; i < total; i++) { + BYN_TRACE("read one at " << pos << std::endl); + auto sizePos = pos; + size_t size = getU32LEB(); + if (size == 0) { + throwError("empty function size"); + } + endOfFunction = pos + size; + + auto* func = new Function; + func->name = Name::fromInt(i); + func->sig = functionSignatures[i]; + currFunction = func; + + if (DWARF) { + func->funcLocation = BinaryLocations::FunctionLocations{ + BinaryLocation(sizePos - codeSectionLocation), + BinaryLocation(pos - codeSectionLocation), + BinaryLocation(pos - codeSectionLocation + size)}; + } + + readNextDebugLocation(); + + BYN_TRACE("reading " << i << std::endl); + size_t numLocalTypes = getU32LEB(); + for (size_t t = 0; t < numLocalTypes; t++) { + auto num = getU32LEB(); + auto type = getConcreteType(); + while (num > 0) { + func->vars.push_back(type); + num--; + } + } + std::swap(func->prologLocation, debugLocation); + { + // process the function body + BYN_TRACE("processing function: " << i << std::endl); + nextLabel = 0; + debugLocation.clear(); + willBeIgnored = false; + // process body + assert(breakTargetNames.size() == 0); + assert(breakStack.empty()); + assert(expressionStack.empty()); + assert(controlFlowStack.empty()); + assert(depth == 0); + func->body = getBlockOrSingleton(func->sig.results); + assert(depth == 0); + assert(breakStack.size() == 0); + assert(breakTargetNames.size() == 0); + if (!expressionStack.empty()) { + throwError("stack not empty on function exit"); + } + assert(controlFlowStack.empty()); + if (pos != endOfFunction) { + throwError("binary offset at function exit not at expected location"); + } + } + std::swap(func->epilogLocation, debugLocation); + currFunction = nullptr; + debugLocation.clear(); + functions.push_back(func); + } + BYN_TRACE(" end function bodies\n"); +} + +void WasmBinaryBuilder::readExports() { + BYN_TRACE("== readExports\n"); + size_t num = getU32LEB(); + BYN_TRACE("num: " << num << std::endl); + std::set names; + for (size_t i = 0; i < num; i++) { + BYN_TRACE("read one\n"); + auto curr = new Export; + curr->name = getInlineString(); + if (names.count(curr->name) > 0) { + throwError("duplicate export name"); + } + names.insert(curr->name); + curr->kind = (ExternalKind)getU32LEB(); + auto index = getU32LEB(); + exportIndices[curr] = index; + exportOrder.push_back(curr); + } +} + +static int32_t readBase64VLQ(std::istream& in) { + uint32_t value = 0; + uint32_t shift = 0; + while (1) { + auto ch = in.get(); + if (ch == EOF) { + throw MapParseException("unexpected EOF in the middle of VLQ"); + } + if ((ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch < 'g')) { + // last number digit + uint32_t digit = ch < 'a' ? ch - 'A' : ch - 'a' + 26; + value |= digit << shift; + break; + } + if (!(ch >= 'g' && ch <= 'z') && !(ch >= '0' && ch <= '9') && ch != '+' && + ch != '/') { + throw MapParseException("invalid VLQ digit"); + } + uint32_t digit = + ch > '9' ? ch - 'g' : (ch >= '0' ? ch - '0' + 20 : (ch == '+' ? 30 : 31)); + value |= digit << shift; + shift += 5; + } + return value & 1 ? -int32_t(value >> 1) : int32_t(value >> 1); +} + +void WasmBinaryBuilder::readSourceMapHeader() { + if (!sourceMap) { + return; + } + + auto skipWhitespace = [&]() { + while (sourceMap->peek() == ' ' || sourceMap->peek() == '\n') { + sourceMap->get(); + } + }; + + auto maybeReadChar = [&](char expected) { + if (sourceMap->peek() != expected) { + return false; + } + sourceMap->get(); + return true; + }; + + auto mustReadChar = [&](char expected) { + char c = sourceMap->get(); + if (c != expected) { + throw MapParseException(std::string("Unexpected char: expected '") + + expected + "' got '" + c + "'"); + } + }; + + auto findField = [&](const char* name) { + bool matching = false; + size_t len = strlen(name); + size_t pos; + while (1) { + int ch = sourceMap->get(); + if (ch == EOF) { + return false; + } + if (ch == '\"') { + if (matching) { + // we matched a terminating quote. + if (pos == len) { + break; + } + matching = false; + } else { + matching = true; + pos = 0; + } + } else if (matching && name[pos] == ch) { + ++pos; + } else if (matching) { + matching = false; + } + } + skipWhitespace(); + mustReadChar(':'); + skipWhitespace(); + return true; + }; + + auto readString = [&](std::string& str) { + std::vector vec; + skipWhitespace(); + mustReadChar('\"'); + if (!maybeReadChar('\"')) { + while (1) { + int ch = sourceMap->get(); + if (ch == EOF) { + throw MapParseException("unexpected EOF in the middle of string"); + } + if (ch == '\"') { + break; + } + vec.push_back(ch); + } + } + skipWhitespace(); + str = std::string(vec.begin(), vec.end()); + }; + + if (!findField("sources")) { + throw MapParseException("cannot find the 'sources' field in map"); + } + + skipWhitespace(); + mustReadChar('['); + if (!maybeReadChar(']')) { + do { + std::string file; + readString(file); + Index index = wasm.debugInfoFileNames.size(); + wasm.debugInfoFileNames.push_back(file); + debugInfoFileIndices[file] = index; + } while (maybeReadChar(',')); + mustReadChar(']'); + } + + if (!findField("mappings")) { + throw MapParseException("cannot find the 'mappings' field in map"); + } + + mustReadChar('\"'); + if (maybeReadChar('\"')) { // empty mappings + nextDebugLocation.first = 0; + return; + } + // read first debug location + uint32_t position = readBase64VLQ(*sourceMap); + uint32_t fileIndex = readBase64VLQ(*sourceMap); + uint32_t lineNumber = + readBase64VLQ(*sourceMap) + 1; // adjust zero-based line number + uint32_t columnNumber = readBase64VLQ(*sourceMap); + nextDebugLocation = {position, {fileIndex, lineNumber, columnNumber}}; +} + +void WasmBinaryBuilder::readNextDebugLocation() { + if (!sourceMap) { + return; + } + + while (nextDebugLocation.first && nextDebugLocation.first <= pos) { + debugLocation.clear(); + // use debugLocation only for function expressions + if (currFunction) { + debugLocation.insert(nextDebugLocation.second); + } + + char ch; + *sourceMap >> ch; + if (ch == '\"') { // end of records + nextDebugLocation.first = 0; + break; + } + if (ch != ',') { + throw MapParseException("Unexpected delimiter"); + } + + int32_t positionDelta = readBase64VLQ(*sourceMap); + uint32_t position = nextDebugLocation.first + positionDelta; + int32_t fileIndexDelta = readBase64VLQ(*sourceMap); + uint32_t fileIndex = nextDebugLocation.second.fileIndex + fileIndexDelta; + int32_t lineNumberDelta = readBase64VLQ(*sourceMap); + uint32_t lineNumber = nextDebugLocation.second.lineNumber + lineNumberDelta; + int32_t columnNumberDelta = readBase64VLQ(*sourceMap); + uint32_t columnNumber = + nextDebugLocation.second.columnNumber + columnNumberDelta; + + nextDebugLocation = {position, {fileIndex, lineNumber, columnNumber}}; + } +} + +Expression* WasmBinaryBuilder::readExpression() { + assert(depth == 0); + processExpressions(); + if (expressionStack.size() != 1) { + throwError("expected to read a single expression"); + } + auto* ret = popExpression(); + assert(depth == 0); + return ret; +} + +void WasmBinaryBuilder::readGlobals() { + BYN_TRACE("== readGlobals\n"); + size_t num = getU32LEB(); + BYN_TRACE("num: " << num << std::endl); + for (size_t i = 0; i < num; i++) { + BYN_TRACE("read one\n"); + auto type = getConcreteType(); + auto mutable_ = getU32LEB(); + if (mutable_ & ~1) { + throwError("Global mutability must be 0 or 1"); + } + auto* init = readExpression(); + globals.push_back( + Builder::makeGlobal("global$" + std::to_string(i), + type, + init, + mutable_ ? Builder::Mutable : Builder::Immutable)); + } +} + +void WasmBinaryBuilder::processExpressions() { + BYN_TRACE("== processExpressions\n"); + unreachableInTheWasmSense = false; + while (1) { + Expression* curr; + auto ret = readExpression(curr); + if (!curr) { + lastSeparator = ret; + BYN_TRACE("== processExpressions finished\n"); + return; + } + pushExpression(curr); + if (curr->type == Type::unreachable) { + // Once we see something unreachable, we don't want to add anything else + // to the stack, as it could be stacky code that is non-representable in + // our AST. but we do need to skip it. + // If there is nothing else here, just stop. Otherwise, go into + // unreachable mode. peek to see what to do. + if (pos == endOfFunction) { + throwError("Reached function end without seeing End opcode"); + } + if (!more()) { + throwError("unexpected end of input"); + } + auto peek = input[pos]; + if (peek == BinaryConsts::End || peek == BinaryConsts::Else || + peek == BinaryConsts::Catch) { + BYN_TRACE("== processExpressions finished with unreachable" + << std::endl); + lastSeparator = BinaryConsts::ASTNodes(peek); + // Read the byte we peeked at. No new instruction is generated for it. + Expression* dummy = nullptr; + readExpression(dummy); + assert(!dummy); + return; + } else { + skipUnreachableCode(); + return; + } + } + } +} + +void WasmBinaryBuilder::skipUnreachableCode() { + BYN_TRACE("== skipUnreachableCode\n"); + // preserve the stack, and restore it. it contains the instruction that made + // us unreachable, and we can ignore anything after it. things after it may + // pop, we want to undo that + auto savedStack = expressionStack; + // note we are entering unreachable code, and note what the state as before so + // we can restore it + auto before = willBeIgnored; + willBeIgnored = true; + // clear the stack. nothing should be popped from there anyhow, just stuff + // can be pushed and then popped. Popping past the top of the stack will + // result in uneachables being returned + expressionStack.clear(); + while (1) { + // set the unreachableInTheWasmSense flag each time, as sub-blocks may set + // and unset it + unreachableInTheWasmSense = true; + Expression* curr; + auto ret = readExpression(curr); + if (!curr) { + BYN_TRACE("== skipUnreachableCode finished\n"); + lastSeparator = ret; + unreachableInTheWasmSense = false; + willBeIgnored = before; + expressionStack = savedStack; + return; + } + pushExpression(curr); + } +} + +void WasmBinaryBuilder::pushExpression(Expression* curr) { + if (curr->type.isTuple()) { + // Store tuple to local and push individual extracted values + Builder builder(wasm); + Index tuple = builder.addVar(currFunction, curr->type); + expressionStack.push_back(builder.makeLocalSet(tuple, curr)); + for (Index i = 0; i < curr->type.size(); ++i) { + expressionStack.push_back( + builder.makeTupleExtract(builder.makeLocalGet(tuple, curr->type), i)); + } + } else { + expressionStack.push_back(curr); + } +} + +Expression* WasmBinaryBuilder::popExpression() { + BYN_TRACE("== popExpression\n"); + if (expressionStack.empty()) { + if (unreachableInTheWasmSense) { + // in unreachable code, trying to pop past the polymorphic stack + // area results in receiving unreachables + BYN_TRACE("== popping unreachable from polymorphic stack" << std::endl); + return allocator.alloc(); + } + throwError( + "attempted pop from empty stack / beyond block start boundary at " + + std::to_string(pos)); + } + // the stack is not empty, and we would not be going out of the current block + auto ret = expressionStack.back(); + assert(!ret->type.isTuple()); + expressionStack.pop_back(); + return ret; +} + +Expression* WasmBinaryBuilder::popNonVoidExpression() { + auto* ret = popExpression(); + if (ret->type != Type::none) { + return ret; + } + // we found a void, so this is stacky code that we must handle carefully + Builder builder(wasm); + // add elements until we find a non-void + std::vector expressions; + expressions.push_back(ret); + while (1) { + auto* curr = popExpression(); + expressions.push_back(curr); + if (curr->type != Type::none) { + break; + } + } + auto* block = builder.makeBlock(); + while (!expressions.empty()) { + block->list.push_back(expressions.back()); + expressions.pop_back(); + } + requireFunctionContext("popping void where we need a new local"); + auto type = block->list[0]->type; + if (type.isConcrete()) { + auto local = builder.addVar(currFunction, type); + block->list[0] = builder.makeLocalSet(local, block->list[0]); + block->list.push_back(builder.makeLocalGet(local, type)); + } else { + assert(type == Type::unreachable); + // nothing to do here - unreachable anyhow + } + block->finalize(); + return block; +} + +Expression* WasmBinaryBuilder::popTuple(size_t numElems) { + Builder builder(wasm); + std::vector elements; + elements.resize(numElems); + for (size_t i = 0; i < numElems; i++) { + auto* elem = popNonVoidExpression(); + if (elem->type == Type::unreachable) { + // All the previously-popped items cannot be reached, so ignore them. We + // cannot continue popping because there might not be enough items on the + // expression stack after an unreachable expression. Any remaining + // elements can stay unperturbed on the stack and will be explicitly + // dropped by some parent call to pushBlockElements. + return elem; + } + elements[numElems - i - 1] = elem; + } + return Builder(wasm).makeTupleMake(std::move(elements)); +} + +Expression* WasmBinaryBuilder::popTypedExpression(Type type) { + if (type.isSingle()) { + return popNonVoidExpression(); + } else if (type.isTuple()) { + return popTuple(type.size()); + } else { + WASM_UNREACHABLE("Invalid popped type"); + } +} + +void WasmBinaryBuilder::validateBinary() { + if (hasDataCount && wasm.memory.segments.size() != dataCount) { + throwError("Number of segments does not agree with DataCount section"); + } +} + +void WasmBinaryBuilder::processNames() { + for (auto* func : functions) { + wasm.addFunction(func); + } + for (auto* global : globals) { + wasm.addGlobal(global); + } + + // now that we have names, apply things + + if (startIndex != static_cast(-1)) { + wasm.start = getFunctionName(startIndex); + } + + for (auto* curr : exportOrder) { + auto index = exportIndices[curr]; + switch (curr->kind) { + case ExternalKind::Function: { + curr->value = getFunctionName(index); + break; + } + case ExternalKind::Table: + curr->value = wasm.table.name; + break; + case ExternalKind::Memory: + curr->value = wasm.memory.name; + break; + case ExternalKind::Global: + curr->value = getGlobalName(index); + break; + case ExternalKind::Event: + curr->value = getEventName(index); + break; + default: + throwError("bad export kind"); + } + wasm.addExport(curr); + } + + for (auto& iter : functionRefs) { + size_t index = iter.first; + auto& refs = iter.second; + for (auto* ref : refs) { + if (auto* call = ref->dynCast()) { + call->target = getFunctionName(index); + } else if (auto* refFunc = ref->dynCast()) { + refFunc->func = getFunctionName(index); + } else { + WASM_UNREACHABLE("Invalid type in function references"); + } + } + } + + for (auto& pair : functionTable) { + auto i = pair.first; + auto& indices = pair.second; + for (auto j : indices) { + wasm.table.segments[i].data.push_back(getFunctionName(j)); + } + } + + for (auto& iter : globalRefs) { + size_t index = iter.first; + auto& refs = iter.second; + for (auto* ref : refs) { + if (auto* get = ref->dynCast()) { + get->name = getGlobalName(index); + } else if (auto* set = ref->dynCast()) { + set->name = getGlobalName(index); + } else { + WASM_UNREACHABLE("Invalid type in global references"); + } + } + } + + // Everything now has its proper name. + + wasm.updateMaps(); +} + +void WasmBinaryBuilder::readDataCount() { + BYN_TRACE("== readDataCount\n"); + hasDataCount = true; + dataCount = getU32LEB(); +} + +void WasmBinaryBuilder::readDataSegments() { + BYN_TRACE("== readDataSegments\n"); + auto num = getU32LEB(); + for (size_t i = 0; i < num; i++) { + Memory::Segment curr; + uint32_t flags = getU32LEB(); + if (flags > 2) { + throwError("bad segment flags, must be 0, 1, or 2, not " + + std::to_string(flags)); + } + curr.isPassive = flags & BinaryConsts::IsPassive; + if (flags & BinaryConsts::HasMemIndex) { + auto memIndex = getU32LEB(); + if (memIndex != 0) { + throwError("nonzero memory index"); + } + } + if (!curr.isPassive) { + curr.offset = readExpression(); + } + auto size = getU32LEB(); + curr.data.resize(size); + for (size_t j = 0; j < size; j++) { + curr.data[j] = char(getInt8()); + } + wasm.memory.segments.push_back(curr); + } +} + +void WasmBinaryBuilder::readFunctionTableDeclaration() { + BYN_TRACE("== readFunctionTableDeclaration\n"); + auto numTables = getU32LEB(); + if (numTables != 1) { + throwError("Only 1 table definition allowed in MVP"); + } + if (wasm.table.exists) { + throwError("Table cannot be both imported and defined"); + } + wasm.table.exists = true; + auto elemType = getS32LEB(); + if (elemType != BinaryConsts::EncodedType::funcref) { + throwError("ElementType must be funcref in MVP"); + } + bool is_shared; + Type indexType; + getResizableLimits(wasm.table.initial, + wasm.table.max, + is_shared, + indexType, + Table::kUnlimitedSize); + if (is_shared) { + throwError("Tables may not be shared"); + } + if (indexType == Type::i64) { + throwError("Tables may not be 64-bit"); + } +} + +void WasmBinaryBuilder::readTableElements() { + BYN_TRACE("== readTableElements\n"); + auto numSegments = getU32LEB(); + if (numSegments >= Table::kMaxSize) { + throwError("Too many segments"); + } + for (size_t i = 0; i < numSegments; i++) { + auto tableIndex = getU32LEB(); + if (tableIndex != 0) { + throwError("Table elements must refer to table 0 in MVP"); + } + wasm.table.segments.emplace_back(readExpression()); + + auto& indexSegment = functionTable[i]; + auto size = getU32LEB(); + for (Index j = 0; j < size; j++) { + indexSegment.push_back(getU32LEB()); + } + } +} + +void WasmBinaryBuilder::readEvents() { + BYN_TRACE("== readEvents\n"); + size_t numEvents = getU32LEB(); + BYN_TRACE("num: " << numEvents << std::endl); + for (size_t i = 0; i < numEvents; i++) { + BYN_TRACE("read one\n"); + auto attribute = getU32LEB(); + auto typeIndex = getU32LEB(); + if (typeIndex >= signatures.size()) { + throwError("invalid event index " + std::to_string(typeIndex) + " / " + + std::to_string(signatures.size())); + } + wasm.addEvent(Builder::makeEvent( + "event$" + std::to_string(i), attribute, signatures[typeIndex])); + } +} + +static bool isIdChar(char ch) { + return (ch >= '0' && ch <= '9') || (ch >= 'A' && ch <= 'Z') || + (ch >= 'a' && ch <= 'z') || ch == '!' || ch == '#' || ch == '$' || + ch == '%' || ch == '&' || ch == '\'' || ch == '*' || ch == '+' || + ch == '-' || ch == '.' || ch == '/' || ch == ':' || ch == '<' || + ch == '=' || ch == '>' || ch == '?' || ch == '@' || ch == '^' || + ch == '_' || ch == '`' || ch == '|' || ch == '~'; +} + +static char formatNibble(int nibble) { + return nibble < 10 ? '0' + nibble : 'a' - 10 + nibble; +} + +Name WasmBinaryBuilder::escape(Name name) { + bool allIdChars = true; + for (const char* p = name.str; allIdChars && *p; p++) { + allIdChars = isIdChar(*p); + } + if (allIdChars) { + return name; + } + // encode name, if at least one non-idchar (per WebAssembly spec) was found + std::string escaped; + for (const char* p = name.str; *p; p++) { + char ch = *p; + if (isIdChar(ch)) { + escaped.push_back(ch); + continue; + } + // replace non-idchar with `\xx` escape + escaped.push_back('\\'); + escaped.push_back(formatNibble(ch >> 4)); + escaped.push_back(formatNibble(ch & 15)); + } + return escaped; +} + +void WasmBinaryBuilder::readNames(size_t payloadLen) { + BYN_TRACE("== readNames\n"); + auto sectionPos = pos; + while (pos < sectionPos + payloadLen) { + auto nameType = getU32LEB(); + auto subsectionSize = getU32LEB(); + auto subsectionPos = pos; + if (nameType == BinaryConsts::UserSections::Subsection::NameModule) { + wasm.name = getInlineString(); + } else if (nameType == + BinaryConsts::UserSections::Subsection::NameFunction) { + auto num = getU32LEB(); + std::set usedNames; + for (size_t i = 0; i < num; i++) { + auto index = getU32LEB(); + auto rawName = getInlineString(); + auto name = escape(rawName); + // De-duplicate names by appending .1, .2, etc. + for (int i = 1; !usedNames.insert(name).second; ++i) { + name = std::string(escape(rawName).str) + std::string(".") + + std::to_string(i); + } + auto numFunctionImports = functionImports.size(); + if (index < numFunctionImports) { + functionImports[index]->name = name; + } else if (index - numFunctionImports < functions.size()) { + functions[index - numFunctionImports]->name = name; + } else { + std::cerr << "warning: function index out of bounds in name section, " + "function subsection: " + << std::string(rawName.str) << " at index " + << std::to_string(index) << std::endl; + } + } + } else if (nameType == BinaryConsts::UserSections::Subsection::NameLocal) { + auto numFuncs = getU32LEB(); + auto numFunctionImports = functionImports.size(); + for (size_t i = 0; i < numFuncs; i++) { + auto funcIndex = getU32LEB(); + Function* func = nullptr; + if (funcIndex < numFunctionImports) { + func = functionImports[funcIndex]; + } else if (funcIndex - numFunctionImports < functions.size()) { + func = functions[funcIndex - numFunctionImports]; + } else { + std::cerr + << "warning: function index out of bounds in name section, local " + "subsection: " + << std::to_string(funcIndex) << std::endl; + } + auto numLocals = getU32LEB(); + std::set usedNames; + for (size_t j = 0; j < numLocals; j++) { + auto localIndex = getU32LEB(); + auto rawLocalName = getInlineString(); + if (!func) { + continue; // read and discard in case of prior error + } + auto localName = escape(rawLocalName); + // De-duplicate names by appending .1, .2, etc. + for (int i = 1; !usedNames.insert(localName).second; ++i) { + localName = std::string(escape(rawLocalName).str) + + std::string(".") + std::to_string(i); + } + if (localIndex < func->getNumLocals()) { + func->localNames[localIndex] = localName; + } else { + std::cerr << "warning: local index out of bounds in name " + "section, local subsection: " + << std::string(rawLocalName.str) << " at index " + << std::to_string(localIndex) << " in function " + << std::string(func->name.str) << std::endl; + } + } + } + } else if (nameType == BinaryConsts::UserSections::Subsection::NameTable) { + auto num = getU32LEB(); + for (size_t i = 0; i < num; i++) { + auto index = getU32LEB(); + auto rawName = getInlineString(); + if (index == 0) { + wasm.table.name = escape(rawName); + } else { + std::cerr << "warning: table index out of bounds in name section, " + "table subsection: " + << std::string(rawName.str) << " at index " + << std::to_string(index) << std::endl; + } + } + } else if (nameType == BinaryConsts::UserSections::Subsection::NameMemory) { + auto num = getU32LEB(); + for (size_t i = 0; i < num; i++) { + auto index = getU32LEB(); + auto rawName = getInlineString(); + if (index == 0) { + wasm.memory.name = escape(rawName); + } else { + std::cerr << "warning: memory index out of bounds in name section, " + "memory subsection: " + << std::string(rawName.str) << " at index " + << std::to_string(index) << std::endl; + } + } + } else if (nameType == BinaryConsts::UserSections::Subsection::NameGlobal) { + auto num = getU32LEB(); + std::set usedNames; + for (size_t i = 0; i < num; i++) { + auto index = getU32LEB(); + auto rawName = getInlineString(); + auto name = escape(rawName); + // De-duplicate names by appending .1, .2, etc. + for (int i = 1; !usedNames.insert(name).second; ++i) { + name = std::string(escape(rawName).str) + std::string(".") + + std::to_string(i); + } + auto numGlobalImports = globalImports.size(); + if (index < numGlobalImports) { + globalImports[index]->name = name; + } else if (index - numGlobalImports < globals.size()) { + globals[index - numGlobalImports]->name = name; + } else { + std::cerr << "warning: global index out of bounds in name section, " + "global subsection: " + << std::string(rawName.str) << " at index " + << std::to_string(index) << std::endl; + } + } + } else { + std::cerr << "warning: unknown name subsection with id " + << std::to_string(nameType) << " at " << pos << std::endl; + pos = subsectionPos + subsectionSize; + } + if (pos != subsectionPos + subsectionSize) { + throwError("bad names subsection position change"); + } + } + if (pos != sectionPos + payloadLen) { + throwError("bad names section position change"); + } +} + +void WasmBinaryBuilder::readFeatures(size_t payloadLen) { + wasm.hasFeaturesSection = true; + wasm.features = FeatureSet::MVP; + + auto sectionPos = pos; + size_t numFeatures = getU32LEB(); + for (size_t i = 0; i < numFeatures; ++i) { + uint8_t prefix = getInt8(); + if (prefix != BinaryConsts::FeatureUsed) { + if (prefix == BinaryConsts::FeatureRequired) { + std::cerr + << "warning: required features in feature section are ignored"; + } else if (prefix == BinaryConsts::FeatureDisallowed) { + std::cerr + << "warning: disallowed features in feature section are ignored"; + } else { + throwError("Unrecognized feature policy prefix"); + } + } + + Name name = getInlineString(); + if (pos > sectionPos + payloadLen) { + throwError("ill-formed string extends beyond section"); + } + + if (prefix != BinaryConsts::FeatureDisallowed) { + if (name == BinaryConsts::UserSections::AtomicsFeature) { + wasm.features.setAtomics(); + } else if (name == BinaryConsts::UserSections::BulkMemoryFeature) { + wasm.features.setBulkMemory(); + } else if (name == BinaryConsts::UserSections::ExceptionHandlingFeature) { + wasm.features.setExceptionHandling(); + } else if (name == BinaryConsts::UserSections::MutableGlobalsFeature) { + wasm.features.setMutableGlobals(); + } else if (name == BinaryConsts::UserSections::TruncSatFeature) { + wasm.features.setTruncSat(); + } else if (name == BinaryConsts::UserSections::SignExtFeature) { + wasm.features.setSignExt(); + } else if (name == BinaryConsts::UserSections::SIMD128Feature) { + wasm.features.setSIMD(); + } else if (name == BinaryConsts::UserSections::TailCallFeature) { + wasm.features.setTailCall(); + } else if (name == BinaryConsts::UserSections::ReferenceTypesFeature) { + wasm.features.setReferenceTypes(); + } else if (name == BinaryConsts::UserSections::MultivalueFeature) { + wasm.features.setMultivalue(); + } else if (name == BinaryConsts::UserSections::GCFeature) { + wasm.features.setGC(); + } else if (name == BinaryConsts::UserSections::Memory64Feature) { + wasm.features.setMemory64(); + } + } + } + if (pos != sectionPos + payloadLen) { + throwError("bad features section size"); + } +} + +void WasmBinaryBuilder::readDylink(size_t payloadLen) { + wasm.dylinkSection = make_unique(); + + auto sectionPos = pos; + + wasm.dylinkSection->memorySize = getU32LEB(); + wasm.dylinkSection->memoryAlignment = getU32LEB(); + wasm.dylinkSection->tableSize = getU32LEB(); + wasm.dylinkSection->tableAlignment = getU32LEB(); + + size_t numNeededDynlibs = getU32LEB(); + for (size_t i = 0; i < numNeededDynlibs; ++i) { + wasm.dylinkSection->neededDynlibs.push_back(getInlineString()); + } + + if (pos != sectionPos + payloadLen) { + throwError("bad features section size"); + } +} + +BinaryConsts::ASTNodes WasmBinaryBuilder::readExpression(Expression*& curr) { + if (pos == endOfFunction) { + throwError("Reached function end without seeing End opcode"); + } + BYN_TRACE("zz recurse into " << ++depth << " at " << pos << std::endl); + readNextDebugLocation(); + std::set currDebugLocation; + if (debugLocation.size()) { + currDebugLocation.insert(*debugLocation.begin()); + } + size_t startPos = pos; + uint8_t code = getInt8(); + BYN_TRACE("readExpression seeing " << (int)code << std::endl); + switch (code) { + case BinaryConsts::Block: + visitBlock((curr = allocator.alloc())->cast()); + break; + case BinaryConsts::If: + visitIf((curr = allocator.alloc())->cast()); + break; + case BinaryConsts::Loop: + visitLoop((curr = allocator.alloc())->cast()); + break; + case BinaryConsts::Br: + case BinaryConsts::BrIf: + visitBreak((curr = allocator.alloc())->cast(), code); + break; // code distinguishes br from br_if + case BinaryConsts::BrTable: + visitSwitch((curr = allocator.alloc())->cast()); + break; + case BinaryConsts::CallFunction: + visitCall((curr = allocator.alloc())->cast()); + break; + case BinaryConsts::CallIndirect: + visitCallIndirect( + (curr = allocator.alloc())->cast()); + break; + case BinaryConsts::RetCallFunction: { + auto call = allocator.alloc(); + call->isReturn = true; + curr = call; + visitCall(call); + break; + } + case BinaryConsts::RetCallIndirect: { + auto call = allocator.alloc(); + call->isReturn = true; + curr = call; + visitCallIndirect(call); + break; + } + case BinaryConsts::LocalGet: + visitLocalGet((curr = allocator.alloc())->cast()); + break; + case BinaryConsts::LocalTee: + case BinaryConsts::LocalSet: + visitLocalSet((curr = allocator.alloc())->cast(), + code); + break; + case BinaryConsts::GlobalGet: + visitGlobalGet((curr = allocator.alloc())->cast()); + break; + case BinaryConsts::GlobalSet: + visitGlobalSet((curr = allocator.alloc())->cast()); + break; + case BinaryConsts::Select: + case BinaryConsts::SelectWithType: + visitSelect((curr = allocator.alloc(), code); + break; + case BinaryConsts::Return: + visitReturn((curr = allocator.alloc())->cast()); + break; + case BinaryConsts::Nop: + visitNop((curr = allocator.alloc())->cast()); + break; + case BinaryConsts::Unreachable: + visitUnreachable( + (curr = allocator.alloc())->cast()); + break; + case BinaryConsts::Drop: + visitDrop((curr = allocator.alloc())->cast()); + break; + case BinaryConsts::End: + curr = nullptr; + continueControlFlow(BinaryLocations::End, startPos); + break; + case BinaryConsts::Else: + curr = nullptr; + continueControlFlow(BinaryLocations::Else, startPos); + break; + case BinaryConsts::Catch: + curr = nullptr; + continueControlFlow(BinaryLocations::Catch, startPos); + break; + case BinaryConsts::RefNull: + visitRefNull((curr = allocator.alloc())->cast()); + break; + case BinaryConsts::RefIsNull: + visitRefIsNull((curr = allocator.alloc())->cast()); + break; + case BinaryConsts::RefFunc: + visitRefFunc((curr = allocator.alloc())->cast()); + break; + case BinaryConsts::RefEq: + visitRefEq((curr = allocator.alloc())->cast()); + break; + case BinaryConsts::Try: + visitTryOrTryInBlock(curr); + break; + case BinaryConsts::Throw: + visitThrow((curr = allocator.alloc())->cast()); + break; + case BinaryConsts::Rethrow: + visitRethrow((curr = allocator.alloc())->cast()); + break; + case BinaryConsts::BrOnExn: + visitBrOnExn((curr = allocator.alloc())->cast()); + break; + case BinaryConsts::MemorySize: { + auto size = allocator.alloc(); + if (wasm.memory.is64()) { + size->make64(); + } + curr = size; + visitMemorySize(size); + break; + } + case BinaryConsts::MemoryGrow: { + auto grow = allocator.alloc(); + if (wasm.memory.is64()) { + grow->make64(); + } + curr = grow; + visitMemoryGrow(grow); + break; + } + case BinaryConsts::AtomicPrefix: { + code = static_cast(getU32LEB()); + if (maybeVisitLoad(curr, code, /*isAtomic=*/true)) { + break; + } + if (maybeVisitStore(curr, code, /*isAtomic=*/true)) { + break; + } + if (maybeVisitAtomicRMW(curr, code)) { + break; + } + if (maybeVisitAtomicCmpxchg(curr, code)) { + break; + } + if (maybeVisitAtomicWait(curr, code)) { + break; + } + if (maybeVisitAtomicNotify(curr, code)) { + break; + } + if (maybeVisitAtomicFence(curr, code)) { + break; + } + throwError("invalid code after atomic prefix: " + std::to_string(code)); + break; + } + case BinaryConsts::MiscPrefix: { + auto opcode = getU32LEB(); + if (maybeVisitTruncSat(curr, opcode)) { + break; + } + if (maybeVisitMemoryInit(curr, opcode)) { + break; + } + if (maybeVisitDataDrop(curr, opcode)) { + break; + } + if (maybeVisitMemoryCopy(curr, opcode)) { + break; + } + if (maybeVisitMemoryFill(curr, opcode)) { + break; + } + throwError("invalid code after nontrapping float-to-int prefix: " + + std::to_string(opcode)); + break; + } + case BinaryConsts::SIMDPrefix: { + auto opcode = getU32LEB(); + if (maybeVisitSIMDBinary(curr, opcode)) { + break; + } + if (maybeVisitSIMDUnary(curr, opcode)) { + break; + } + if (maybeVisitSIMDConst(curr, opcode)) { + break; + } + if (maybeVisitSIMDStore(curr, opcode)) { + break; + } + if (maybeVisitSIMDExtract(curr, opcode)) { + break; + } + if (maybeVisitSIMDReplace(curr, opcode)) { + break; + } + if (maybeVisitSIMDShuffle(curr, opcode)) { + break; + } + if (maybeVisitSIMDTernary(curr, opcode)) { + break; + } + if (maybeVisitSIMDShift(curr, opcode)) { + break; + } + if (maybeVisitSIMDLoad(curr, opcode)) { + break; + } + throwError("invalid code after SIMD prefix: " + std::to_string(opcode)); + break; + } + case BinaryConsts::GCPrefix: { + auto opcode = getU32LEB(); + if (maybeVisitI31New(curr, opcode)) { + break; + } + if (maybeVisitI31Get(curr, opcode)) { + break; + } + if (maybeVisitRefTest(curr, opcode)) { + break; + } + if (maybeVisitRefCast(curr, opcode)) { + break; + } + if (maybeVisitBrOnCast(curr, opcode)) { + break; + } + if (maybeVisitRttCanon(curr, opcode)) { + break; + } + if (maybeVisitRttSub(curr, opcode)) { + break; + } + if (maybeVisitStructNew(curr, opcode)) { + break; + } + if (maybeVisitStructGet(curr, opcode)) { + break; + } + if (maybeVisitStructSet(curr, opcode)) { + break; + } + if (maybeVisitArrayNew(curr, opcode)) { + break; + } + if (maybeVisitArrayGet(curr, opcode)) { + break; + } + if (maybeVisitArraySet(curr, opcode)) { + break; + } + if (maybeVisitArrayLen(curr, opcode)) { + break; + } + throwError("invalid code after GC prefix: " + std::to_string(opcode)); + break; + } + default: { + // otherwise, the code is a subcode TODO: optimize + if (maybeVisitBinary(curr, code)) { + break; + } + if (maybeVisitUnary(curr, code)) { + break; + } + if (maybeVisitConst(curr, code)) { + break; + } + if (maybeVisitLoad(curr, code, /*isAtomic=*/false)) { + break; + } + if (maybeVisitStore(curr, code, /*isAtomic=*/false)) { + break; + } + throwError("bad node code " + std::to_string(code)); + break; + } + } + if (curr) { + if (currDebugLocation.size()) { + currFunction->debugLocations[curr] = *currDebugLocation.begin(); + } + if (DWARF && currFunction) { + currFunction->expressionLocations[curr] = + BinaryLocations::Span{BinaryLocation(startPos - codeSectionLocation), + BinaryLocation(pos - codeSectionLocation)}; + } + } + BYN_TRACE("zz recurse from " << depth-- << " at " << pos << std::endl); + return BinaryConsts::ASTNodes(code); +} + +void WasmBinaryBuilder::startControlFlow(Expression* curr) { + if (DWARF && currFunction) { + controlFlowStack.push_back(curr); + } +} + +void WasmBinaryBuilder::continueControlFlow(BinaryLocations::DelimiterId id, + BinaryLocation pos) { + if (DWARF && currFunction) { + if (controlFlowStack.empty()) { + // We reached the end of the function, which is also marked with an + // "end", like a control flow structure. + assert(id == BinaryLocations::End); + assert(pos + 1 == endOfFunction); + return; + } + assert(!controlFlowStack.empty()); + auto currControlFlow = controlFlowStack.back(); + // We are called after parsing the byte, so we need to subtract one to + // get its position. + currFunction->delimiterLocations[currControlFlow][id] = + pos - codeSectionLocation; + if (id == BinaryLocations::End) { + controlFlowStack.pop_back(); + } + } +} + +void WasmBinaryBuilder::pushBlockElements(Block* curr, + Type type, + size_t start) { + assert(start <= expressionStack.size()); + // The results of this block are the last values pushed to the expressionStack + Expression* results = nullptr; + if (type.isConcrete()) { + results = popTypedExpression(type); + } + if (expressionStack.size() < start) { + throwError("Block requires more values than are available"); + } + // Everything else on the stack after `start` is either a none-type expression + // or a concretely-type expression that is implicitly dropped due to + // unreachability at the end of the block, like this: + // + // block i32 + // i32.const 1 + // i32.const 2 + // i32.const 3 + // return + // end + // + // The first two const elements will be emitted as drops in the block (the + // optimizer can remove them, of course, but in general we may need dropped + // items here as they may have side effects). + // + for (size_t i = start; i < expressionStack.size(); ++i) { + auto* item = expressionStack[i]; + if (item->type.isConcrete()) { + item = Builder(wasm).makeDrop(item); + } + curr->list.push_back(item); + } + expressionStack.resize(start); + if (results != nullptr) { + curr->list.push_back(results); + } +} + +void WasmBinaryBuilder::visitBlock(Block* curr) { + BYN_TRACE("zz node: Block\n"); + startControlFlow(curr); + // special-case Block and de-recurse nested blocks in their first position, as + // that is a common pattern that can be very highly nested. + std::vector stack; + while (1) { + curr->type = getType(); + curr->name = getNextLabel(); + breakStack.push_back({curr->name, curr->type}); + stack.push_back(curr); + if (more() && input[pos] == BinaryConsts::Block) { + // a recursion + readNextDebugLocation(); + curr = allocator.alloc(); + startControlFlow(curr); + pos++; + if (debugLocation.size()) { + currFunction->debugLocations[curr] = *debugLocation.begin(); + } + continue; + } else { + // end of recursion + break; + } + } + Block* last = nullptr; + while (stack.size() > 0) { + curr = stack.back(); + stack.pop_back(); + // everything after this, that is left when we see the marker, is ours + size_t start = expressionStack.size(); + if (last) { + // the previous block is our first-position element + pushExpression(last); + } + last = curr; + processExpressions(); + size_t end = expressionStack.size(); + if (end < start) { + throwError("block cannot pop from outside"); + } + pushBlockElements(curr, curr->type, start); + curr->finalize(curr->type, + breakTargetNames.find(curr->name) != + breakTargetNames.end() /* hasBreak */); + breakStack.pop_back(); + breakTargetNames.erase(curr->name); + } +} + +// Gets a block of expressions. If it's just one, return that singleton. +Expression* WasmBinaryBuilder::getBlockOrSingleton(Type type) { + Name label = getNextLabel(); + breakStack.push_back({label, type}); + auto start = expressionStack.size(); + + processExpressions(); + size_t end = expressionStack.size(); + if (end < start) { + throwError("block cannot pop from outside"); + } + breakStack.pop_back(); + auto* block = allocator.alloc(); + pushBlockElements(block, type, start); + block->name = label; + block->finalize(type); + // maybe we don't need a block here? + if (breakTargetNames.find(block->name) == breakTargetNames.end()) { + block->name = Name(); + if (block->list.size() == 1) { + return block->list[0]; + } + } + breakTargetNames.erase(block->name); + return block; +} + +void WasmBinaryBuilder::visitIf(If* curr) { + BYN_TRACE("zz node: If\n"); + startControlFlow(curr); + curr->type = getType(); + curr->condition = popNonVoidExpression(); + curr->ifTrue = getBlockOrSingleton(curr->type); + if (lastSeparator == BinaryConsts::Else) { + curr->ifFalse = getBlockOrSingleton(curr->type); + } + curr->finalize(curr->type); + if (lastSeparator != BinaryConsts::End) { + throwError("if should end with End"); + } +} + +void WasmBinaryBuilder::visitLoop(Loop* curr) { + BYN_TRACE("zz node: Loop\n"); + startControlFlow(curr); + curr->type = getType(); + curr->name = getNextLabel(); + breakStack.push_back({curr->name, Type::none}); + // find the expressions in the block, and create the body + // a loop may have a list of instructions in wasm, much like + // a block, but it only has a label at the top of the loop, + // so even if we need a block (if there is more than 1 + // expression) we never need a label on the block. + auto start = expressionStack.size(); + processExpressions(); + size_t end = expressionStack.size(); + if (start > end) { + throwError("block cannot pop from outside"); + } + if (end - start == 1) { + curr->body = popExpression(); + } else { + auto* block = allocator.alloc(); + pushBlockElements(block, curr->type, start); + block->finalize(curr->type); + curr->body = block; + } + breakStack.pop_back(); + breakTargetNames.erase(curr->name); + curr->finalize(curr->type); +} + +WasmBinaryBuilder::BreakTarget +WasmBinaryBuilder::getBreakTarget(int32_t offset) { + BYN_TRACE("getBreakTarget " << offset << std::endl); + if (breakStack.size() < 1 + size_t(offset)) { + throwError("bad breakindex (low)"); + } + size_t index = breakStack.size() - 1 - offset; + if (index >= breakStack.size()) { + throwError("bad breakindex (high)"); + } + BYN_TRACE("breaktarget " << breakStack[index].name << " type " + << breakStack[index].type << std::endl); + auto& ret = breakStack[index]; + // if the break is in literally unreachable code, then we will not emit it + // anyhow, so do not note that the target has breaks to it + if (!willBeIgnored) { + breakTargetNames.insert(ret.name); + } + return ret; +} + +void WasmBinaryBuilder::visitBreak(Break* curr, uint8_t code) { + BYN_TRACE("zz node: Break, code " << int32_t(code) << std::endl); + BreakTarget target = getBreakTarget(getU32LEB()); + curr->name = target.name; + if (code == BinaryConsts::BrIf) { + curr->condition = popNonVoidExpression(); + } + if (target.type.isConcrete()) { + curr->value = popTypedExpression(target.type); + } + curr->finalize(); +} + +void WasmBinaryBuilder::visitSwitch(Switch* curr) { + BYN_TRACE("zz node: Switch\n"); + curr->condition = popNonVoidExpression(); + auto numTargets = getU32LEB(); + BYN_TRACE("targets: " << numTargets << std::endl); + for (size_t i = 0; i < numTargets; i++) { + curr->targets.push_back(getBreakTarget(getU32LEB()).name); + } + auto defaultTarget = getBreakTarget(getU32LEB()); + curr->default_ = defaultTarget.name; + BYN_TRACE("default: " << curr->default_ << "\n"); + if (defaultTarget.type.isConcrete()) { + curr->value = popTypedExpression(defaultTarget.type); + } + curr->finalize(); +} + +void WasmBinaryBuilder::visitCall(Call* curr) { + BYN_TRACE("zz node: Call\n"); + auto index = getU32LEB(); + Signature sig; + if (index < functionImports.size()) { + auto* import = functionImports[index]; + sig = import->sig; + } else { + Index adjustedIndex = index - functionImports.size(); + if (adjustedIndex >= functionSignatures.size()) { + throwError("invalid call index"); + } + sig = functionSignatures[adjustedIndex]; + } + auto num = sig.params.size(); + curr->operands.resize(num); + for (size_t i = 0; i < num; i++) { + curr->operands[num - i - 1] = popNonVoidExpression(); + } + curr->type = sig.results; + functionRefs[index].push_back(curr); // we don't know function names yet + curr->finalize(); +} + +void WasmBinaryBuilder::visitCallIndirect(CallIndirect* curr) { + BYN_TRACE("zz node: CallIndirect\n"); + auto index = getU32LEB(); + if (index >= signatures.size()) { + throwError("bad call_indirect function index"); + } + curr->sig = signatures[index]; + auto reserved = getU32LEB(); + if (reserved != 0) { + throwError("Invalid flags field in call_indirect"); + } + auto num = curr->sig.params.size(); + curr->operands.resize(num); + curr->target = popNonVoidExpression(); + for (size_t i = 0; i < num; i++) { + curr->operands[num - i - 1] = popNonVoidExpression(); + } + curr->finalize(); +} + +void WasmBinaryBuilder::visitLocalGet(LocalGet* curr) { + BYN_TRACE("zz node: LocalGet " << pos << std::endl); + ; + requireFunctionContext("local.get"); + curr->index = getU32LEB(); + if (curr->index >= currFunction->getNumLocals()) { + throwError("bad local.get index"); + } + curr->type = currFunction->getLocalType(curr->index); + curr->finalize(); +} + +void WasmBinaryBuilder::visitLocalSet(LocalSet* curr, uint8_t code) { + BYN_TRACE("zz node: Set|LocalTee\n"); + requireFunctionContext("local.set outside of function"); + curr->index = getU32LEB(); + if (curr->index >= currFunction->getNumLocals()) { + throwError("bad local.set index"); + } + curr->value = popNonVoidExpression(); + if (code == BinaryConsts::LocalTee) { + curr->makeTee(currFunction->getLocalType(curr->index)); + } else { + curr->makeSet(); + } + curr->finalize(); +} + +void WasmBinaryBuilder::visitGlobalGet(GlobalGet* curr) { + BYN_TRACE("zz node: GlobalGet " << pos << std::endl); + auto index = getU32LEB(); + if (index < globalImports.size()) { + auto* import = globalImports[index]; + curr->name = import->name; + curr->type = import->type; + } else { + Index adjustedIndex = index - globalImports.size(); + if (adjustedIndex >= globals.size()) { + throwError("invalid global index"); + } + auto* glob = globals[adjustedIndex]; + curr->name = glob->name; + curr->type = glob->type; + } + globalRefs[index].push_back(curr); // we don't know the final name yet +} + +void WasmBinaryBuilder::visitGlobalSet(GlobalSet* curr) { + BYN_TRACE("zz node: GlobalSet\n"); + auto index = getU32LEB(); + if (index < globalImports.size()) { + auto* import = globalImports[index]; + curr->name = import->name; + } else { + Index adjustedIndex = index - globalImports.size(); + if (adjustedIndex >= globals.size()) { + throwError("invalid global index"); + } + curr->name = globals[adjustedIndex]->name; + } + curr->value = popNonVoidExpression(); + globalRefs[index].push_back(curr); // we don't know the final name yet + curr->finalize(); +} + +void WasmBinaryBuilder::readMemoryAccess(Address& alignment, Address& offset) { + auto rawAlignment = getU32LEB(); + if (rawAlignment > 4) { + throwError("Alignment must be of a reasonable size"); + } + alignment = Bits::pow2(rawAlignment); + offset = getU32LEB(); +} + +bool WasmBinaryBuilder::maybeVisitLoad(Expression*& out, + uint8_t code, + bool isAtomic) { + Load* curr; + if (!isAtomic) { + switch (code) { + case BinaryConsts::I32LoadMem8S: + curr = allocator.alloc(); + curr->bytes = 1; + curr->type = Type::i32; + curr->signed_ = true; + break; + case BinaryConsts::I32LoadMem8U: + curr = allocator.alloc(); + curr->bytes = 1; + curr->type = Type::i32; + curr->signed_ = false; + break; + case BinaryConsts::I32LoadMem16S: + curr = allocator.alloc(); + curr->bytes = 2; + curr->type = Type::i32; + curr->signed_ = true; + break; + case BinaryConsts::I32LoadMem16U: + curr = allocator.alloc(); + curr->bytes = 2; + curr->type = Type::i32; + curr->signed_ = false; + break; + case BinaryConsts::I32LoadMem: + curr = allocator.alloc(); + curr->bytes = 4; + curr->type = Type::i32; + break; + case BinaryConsts::I64LoadMem8S: + curr = allocator.alloc(); + curr->bytes = 1; + curr->type = Type::i64; + curr->signed_ = true; + break; + case BinaryConsts::I64LoadMem8U: + curr = allocator.alloc(); + curr->bytes = 1; + curr->type = Type::i64; + curr->signed_ = false; + break; + case BinaryConsts::I64LoadMem16S: + curr = allocator.alloc(); + curr->bytes = 2; + curr->type = Type::i64; + curr->signed_ = true; + break; + case BinaryConsts::I64LoadMem16U: + curr = allocator.alloc(); + curr->bytes = 2; + curr->type = Type::i64; + curr->signed_ = false; + break; + case BinaryConsts::I64LoadMem32S: + curr = allocator.alloc(); + curr->bytes = 4; + curr->type = Type::i64; + curr->signed_ = true; + break; + case BinaryConsts::I64LoadMem32U: + curr = allocator.alloc(); + curr->bytes = 4; + curr->type = Type::i64; + curr->signed_ = false; + break; + case BinaryConsts::I64LoadMem: + curr = allocator.alloc(); + curr->bytes = 8; + curr->type = Type::i64; + break; + case BinaryConsts::F32LoadMem: + curr = allocator.alloc(); + curr->bytes = 4; + curr->type = Type::f32; + break; + case BinaryConsts::F64LoadMem: + curr = allocator.alloc(); + curr->bytes = 8; + curr->type = Type::f64; + break; + default: + return false; + } + BYN_TRACE("zz node: Load\n"); + } else { + switch (code) { + case BinaryConsts::I32AtomicLoad8U: + curr = allocator.alloc(); + curr->bytes = 1; + curr->type = Type::i32; + break; + case BinaryConsts::I32AtomicLoad16U: + curr = allocator.alloc(); + curr->bytes = 2; + curr->type = Type::i32; + break; + case BinaryConsts::I32AtomicLoad: + curr = allocator.alloc(); + curr->bytes = 4; + curr->type = Type::i32; + break; + case BinaryConsts::I64AtomicLoad8U: + curr = allocator.alloc(); + curr->bytes = 1; + curr->type = Type::i64; + break; + case BinaryConsts::I64AtomicLoad16U: + curr = allocator.alloc(); + curr->bytes = 2; + curr->type = Type::i64; + break; + case BinaryConsts::I64AtomicLoad32U: + curr = allocator.alloc(); + curr->bytes = 4; + curr->type = Type::i64; + break; + case BinaryConsts::I64AtomicLoad: + curr = allocator.alloc(); + curr->bytes = 8; + curr->type = Type::i64; + break; + default: + return false; + } + curr->signed_ = false; + BYN_TRACE("zz node: AtomicLoad\n"); + } + + curr->isAtomic = isAtomic; + readMemoryAccess(curr->align, curr->offset); + curr->ptr = popNonVoidExpression(); + curr->finalize(); + out = curr; + return true; +} + +bool WasmBinaryBuilder::maybeVisitStore(Expression*& out, + uint8_t code, + bool isAtomic) { + Store* curr; + if (!isAtomic) { + switch (code) { + case BinaryConsts::I32StoreMem8: + curr = allocator.alloc(); + curr->bytes = 1; + curr->valueType = Type::i32; + break; + case BinaryConsts::I32StoreMem16: + curr = allocator.alloc(); + curr->bytes = 2; + curr->valueType = Type::i32; + break; + case BinaryConsts::I32StoreMem: + curr = allocator.alloc(); + curr->bytes = 4; + curr->valueType = Type::i32; + break; + case BinaryConsts::I64StoreMem8: + curr = allocator.alloc(); + curr->bytes = 1; + curr->valueType = Type::i64; + break; + case BinaryConsts::I64StoreMem16: + curr = allocator.alloc(); + curr->bytes = 2; + curr->valueType = Type::i64; + break; + case BinaryConsts::I64StoreMem32: + curr = allocator.alloc(); + curr->bytes = 4; + curr->valueType = Type::i64; + break; + case BinaryConsts::I64StoreMem: + curr = allocator.alloc(); + curr->bytes = 8; + curr->valueType = Type::i64; + break; + case BinaryConsts::F32StoreMem: + curr = allocator.alloc(); + curr->bytes = 4; + curr->valueType = Type::f32; + break; + case BinaryConsts::F64StoreMem: + curr = allocator.alloc(); + curr->bytes = 8; + curr->valueType = Type::f64; + break; + default: + return false; + } + } else { + switch (code) { + case BinaryConsts::I32AtomicStore8: + curr = allocator.alloc(); + curr->bytes = 1; + curr->valueType = Type::i32; + break; + case BinaryConsts::I32AtomicStore16: + curr = allocator.alloc(); + curr->bytes = 2; + curr->valueType = Type::i32; + break; + case BinaryConsts::I32AtomicStore: + curr = allocator.alloc(); + curr->bytes = 4; + curr->valueType = Type::i32; + break; + case BinaryConsts::I64AtomicStore8: + curr = allocator.alloc(); + curr->bytes = 1; + curr->valueType = Type::i64; + break; + case BinaryConsts::I64AtomicStore16: + curr = allocator.alloc(); + curr->bytes = 2; + curr->valueType = Type::i64; + break; + case BinaryConsts::I64AtomicStore32: + curr = allocator.alloc(); + curr->bytes = 4; + curr->valueType = Type::i64; + break; + case BinaryConsts::I64AtomicStore: + curr = allocator.alloc(); + curr->bytes = 8; + curr->valueType = Type::i64; + break; + default: + return false; + } + } + + curr->isAtomic = isAtomic; + BYN_TRACE("zz node: Store\n"); + readMemoryAccess(curr->align, curr->offset); + curr->value = popNonVoidExpression(); + curr->ptr = popNonVoidExpression(); + curr->finalize(); + out = curr; + return true; +} + +bool WasmBinaryBuilder::maybeVisitAtomicRMW(Expression*& out, uint8_t code) { + if (code < BinaryConsts::AtomicRMWOps_Begin || + code > BinaryConsts::AtomicRMWOps_End) { + return false; + } + auto* curr = allocator.alloc(); + + // Set curr to the given opcode, type and size. +#define SET(opcode, optype, size) \ + curr->op = opcode; \ + curr->type = optype; \ + curr->bytes = size + + // Handle the cases for all the valid types for a particular opcode +#define SET_FOR_OP(Op) \ + case BinaryConsts::I32AtomicRMW##Op: \ + SET(Op, Type::i32, 4); \ + break; \ + case BinaryConsts::I32AtomicRMW##Op##8U: \ + SET(Op, Type::i32, 1); \ + break; \ + case BinaryConsts::I32AtomicRMW##Op##16U: \ + SET(Op, Type::i32, 2); \ + break; \ + case BinaryConsts::I64AtomicRMW##Op: \ + SET(Op, Type::i64, 8); \ + break; \ + case BinaryConsts::I64AtomicRMW##Op##8U: \ + SET(Op, Type::i64, 1); \ + break; \ + case BinaryConsts::I64AtomicRMW##Op##16U: \ + SET(Op, Type::i64, 2); \ + break; \ + case BinaryConsts::I64AtomicRMW##Op##32U: \ + SET(Op, Type::i64, 4); \ + break; + + switch (code) { + SET_FOR_OP(Add); + SET_FOR_OP(Sub); + SET_FOR_OP(And); + SET_FOR_OP(Or); + SET_FOR_OP(Xor); + SET_FOR_OP(Xchg); + default: + WASM_UNREACHABLE("unexpected opcode"); + } +#undef SET_FOR_OP +#undef SET + + BYN_TRACE("zz node: AtomicRMW\n"); + Address readAlign; + readMemoryAccess(readAlign, curr->offset); + if (readAlign != curr->bytes) { + throwError("Align of AtomicRMW must match size"); + } + curr->value = popNonVoidExpression(); + curr->ptr = popNonVoidExpression(); + curr->finalize(); + out = curr; + return true; +} + +bool WasmBinaryBuilder::maybeVisitAtomicCmpxchg(Expression*& out, + uint8_t code) { + if (code < BinaryConsts::AtomicCmpxchgOps_Begin || + code > BinaryConsts::AtomicCmpxchgOps_End) { + return false; + } + auto* curr = allocator.alloc(); + + // Set curr to the given type and size. +#define SET(optype, size) \ + curr->type = optype; \ + curr->bytes = size + + switch (code) { + case BinaryConsts::I32AtomicCmpxchg: + SET(Type::i32, 4); + break; + case BinaryConsts::I64AtomicCmpxchg: + SET(Type::i64, 8); + break; + case BinaryConsts::I32AtomicCmpxchg8U: + SET(Type::i32, 1); + break; + case BinaryConsts::I32AtomicCmpxchg16U: + SET(Type::i32, 2); + break; + case BinaryConsts::I64AtomicCmpxchg8U: + SET(Type::i64, 1); + break; + case BinaryConsts::I64AtomicCmpxchg16U: + SET(Type::i64, 2); + break; + case BinaryConsts::I64AtomicCmpxchg32U: + SET(Type::i64, 4); + break; + default: + WASM_UNREACHABLE("unexpected opcode"); + } + + BYN_TRACE("zz node: AtomicCmpxchg\n"); + Address readAlign; + readMemoryAccess(readAlign, curr->offset); + if (readAlign != curr->bytes) { + throwError("Align of AtomicCpxchg must match size"); + } + curr->replacement = popNonVoidExpression(); + curr->expected = popNonVoidExpression(); + curr->ptr = popNonVoidExpression(); + curr->finalize(); + out = curr; + return true; +} + +bool WasmBinaryBuilder::maybeVisitAtomicWait(Expression*& out, uint8_t code) { + if (code < BinaryConsts::I32AtomicWait || + code > BinaryConsts::I64AtomicWait) { + return false; + } + auto* curr = allocator.alloc(); + + switch (code) { + case BinaryConsts::I32AtomicWait: + curr->expectedType = Type::i32; + break; + case BinaryConsts::I64AtomicWait: + curr->expectedType = Type::i64; + break; + default: + WASM_UNREACHABLE("unexpected opcode"); + } + curr->type = Type::i32; + BYN_TRACE("zz node: AtomicWait\n"); + curr->timeout = popNonVoidExpression(); + curr->expected = popNonVoidExpression(); + curr->ptr = popNonVoidExpression(); + Address readAlign; + readMemoryAccess(readAlign, curr->offset); + if (readAlign != curr->expectedType.getByteSize()) { + throwError("Align of AtomicWait must match size"); + } + curr->finalize(); + out = curr; + return true; +} + +bool WasmBinaryBuilder::maybeVisitAtomicNotify(Expression*& out, uint8_t code) { + if (code != BinaryConsts::AtomicNotify) { + return false; + } + auto* curr = allocator.alloc(); + BYN_TRACE("zz node: AtomicNotify\n"); + + curr->type = Type::i32; + curr->notifyCount = popNonVoidExpression(); + curr->ptr = popNonVoidExpression(); + Address readAlign; + readMemoryAccess(readAlign, curr->offset); + if (readAlign != curr->type.getByteSize()) { + throwError("Align of AtomicNotify must match size"); + } + curr->finalize(); + out = curr; + return true; +} + +bool WasmBinaryBuilder::maybeVisitAtomicFence(Expression*& out, uint8_t code) { + if (code != BinaryConsts::AtomicFence) { + return false; + } + auto* curr = allocator.alloc(); + BYN_TRACE("zz node: AtomicFence\n"); + curr->order = getU32LEB(); + curr->finalize(); + out = curr; + return true; +} + +bool WasmBinaryBuilder::maybeVisitConst(Expression*& out, uint8_t code) { + Const* curr; + BYN_TRACE("zz node: Const, code " << code << std::endl); + switch (code) { + case BinaryConsts::I32Const: + curr = allocator.alloc(); + curr->value = Literal(getS32LEB()); + break; + case BinaryConsts::I64Const: + curr = allocator.alloc(); + curr->value = Literal(getS64LEB()); + break; + case BinaryConsts::F32Const: + curr = allocator.alloc(); + curr->value = getFloat32Literal(); + break; + case BinaryConsts::F64Const: + curr = allocator.alloc(); + curr->value = getFloat64Literal(); + break; + default: + return false; + } + curr->type = curr->value.type; + out = curr; + + return true; +} + +bool WasmBinaryBuilder::maybeVisitUnary(Expression*& out, uint8_t code) { + Unary* curr; + switch (code) { + case BinaryConsts::I32Clz: + curr = allocator.alloc(); + curr->op = ClzInt32; + break; + case BinaryConsts::I64Clz: + curr = allocator.alloc(); + curr->op = ClzInt64; + break; + case BinaryConsts::I32Ctz: + curr = allocator.alloc(); + curr->op = CtzInt32; + break; + case BinaryConsts::I64Ctz: + curr = allocator.alloc(); + curr->op = CtzInt64; + break; + case BinaryConsts::I32Popcnt: + curr = allocator.alloc(); + curr->op = PopcntInt32; + break; + case BinaryConsts::I64Popcnt: + curr = allocator.alloc(); + curr->op = PopcntInt64; + break; + case BinaryConsts::I32EqZ: + curr = allocator.alloc(); + curr->op = EqZInt32; + break; + case BinaryConsts::I64EqZ: + curr = allocator.alloc(); + curr->op = EqZInt64; + break; + case BinaryConsts::F32Neg: + curr = allocator.alloc(); + curr->op = NegFloat32; + break; + case BinaryConsts::F64Neg: + curr = allocator.alloc(); + curr->op = NegFloat64; + break; + case BinaryConsts::F32Abs: + curr = allocator.alloc(); + curr->op = AbsFloat32; + break; + case BinaryConsts::F64Abs: + curr = allocator.alloc(); + curr->op = AbsFloat64; + break; + case BinaryConsts::F32Ceil: + curr = allocator.alloc(); + curr->op = CeilFloat32; + break; + case BinaryConsts::F64Ceil: + curr = allocator.alloc(); + curr->op = CeilFloat64; + break; + case BinaryConsts::F32Floor: + curr = allocator.alloc(); + curr->op = FloorFloat32; + break; + case BinaryConsts::F64Floor: + curr = allocator.alloc(); + curr->op = FloorFloat64; + break; + case BinaryConsts::F32NearestInt: + curr = allocator.alloc(); + curr->op = NearestFloat32; + break; + case BinaryConsts::F64NearestInt: + curr = allocator.alloc(); + curr->op = NearestFloat64; + break; + case BinaryConsts::F32Sqrt: + curr = allocator.alloc(); + curr->op = SqrtFloat32; + break; + case BinaryConsts::F64Sqrt: + curr = allocator.alloc(); + curr->op = SqrtFloat64; + break; + case BinaryConsts::F32UConvertI32: + curr = allocator.alloc(); + curr->op = ConvertUInt32ToFloat32; + break; + case BinaryConsts::F64UConvertI32: + curr = allocator.alloc(); + curr->op = ConvertUInt32ToFloat64; + break; + case BinaryConsts::F32SConvertI32: + curr = allocator.alloc(); + curr->op = ConvertSInt32ToFloat32; + break; + case BinaryConsts::F64SConvertI32: + curr = allocator.alloc(); + curr->op = ConvertSInt32ToFloat64; + break; + case BinaryConsts::F32UConvertI64: + curr = allocator.alloc(); + curr->op = ConvertUInt64ToFloat32; + break; + case BinaryConsts::F64UConvertI64: + curr = allocator.alloc(); + curr->op = ConvertUInt64ToFloat64; + break; + case BinaryConsts::F32SConvertI64: + curr = allocator.alloc(); + curr->op = ConvertSInt64ToFloat32; + break; + case BinaryConsts::F64SConvertI64: + curr = allocator.alloc(); + curr->op = ConvertSInt64ToFloat64; + break; + + case BinaryConsts::I64SExtendI32: + curr = allocator.alloc(); + curr->op = ExtendSInt32; + break; + case BinaryConsts::I64UExtendI32: + curr = allocator.alloc(); + curr->op = ExtendUInt32; + break; + case BinaryConsts::I32WrapI64: + curr = allocator.alloc(); + curr->op = WrapInt64; + break; + + case BinaryConsts::I32UTruncF32: + curr = allocator.alloc(); + curr->op = TruncUFloat32ToInt32; + break; + case BinaryConsts::I32UTruncF64: + curr = allocator.alloc(); + curr->op = TruncUFloat64ToInt32; + break; + case BinaryConsts::I32STruncF32: + curr = allocator.alloc(); + curr->op = TruncSFloat32ToInt32; + break; + case BinaryConsts::I32STruncF64: + curr = allocator.alloc(); + curr->op = TruncSFloat64ToInt32; + break; + case BinaryConsts::I64UTruncF32: + curr = allocator.alloc(); + curr->op = TruncUFloat32ToInt64; + break; + case BinaryConsts::I64UTruncF64: + curr = allocator.alloc(); + curr->op = TruncUFloat64ToInt64; + break; + case BinaryConsts::I64STruncF32: + curr = allocator.alloc(); + curr->op = TruncSFloat32ToInt64; + break; + case BinaryConsts::I64STruncF64: + curr = allocator.alloc(); + curr->op = TruncSFloat64ToInt64; + break; + + case BinaryConsts::F32Trunc: + curr = allocator.alloc(); + curr->op = TruncFloat32; + break; + case BinaryConsts::F64Trunc: + curr = allocator.alloc(); + curr->op = TruncFloat64; + break; + + case BinaryConsts::F32DemoteI64: + curr = allocator.alloc(); + curr->op = DemoteFloat64; + break; + case BinaryConsts::F64PromoteF32: + curr = allocator.alloc(); + curr->op = PromoteFloat32; + break; + case BinaryConsts::I32ReinterpretF32: + curr = allocator.alloc(); + curr->op = ReinterpretFloat32; + break; + case BinaryConsts::I64ReinterpretF64: + curr = allocator.alloc(); + curr->op = ReinterpretFloat64; + break; + case BinaryConsts::F32ReinterpretI32: + curr = allocator.alloc(); + curr->op = ReinterpretInt32; + break; + case BinaryConsts::F64ReinterpretI64: + curr = allocator.alloc(); + curr->op = ReinterpretInt64; + break; + + case BinaryConsts::I32ExtendS8: + curr = allocator.alloc(); + curr->op = ExtendS8Int32; + break; + case BinaryConsts::I32ExtendS16: + curr = allocator.alloc(); + curr->op = ExtendS16Int32; + break; + case BinaryConsts::I64ExtendS8: + curr = allocator.alloc(); + curr->op = ExtendS8Int64; + break; + case BinaryConsts::I64ExtendS16: + curr = allocator.alloc(); + curr->op = ExtendS16Int64; + break; + case BinaryConsts::I64ExtendS32: + curr = allocator.alloc(); + curr->op = ExtendS32Int64; + break; + + default: + return false; + } + BYN_TRACE("zz node: Unary\n"); + curr->value = popNonVoidExpression(); + curr->finalize(); + out = curr; + return true; +} + +bool WasmBinaryBuilder::maybeVisitTruncSat(Expression*& out, uint32_t code) { + Unary* curr; + switch (code) { + case BinaryConsts::I32STruncSatF32: + curr = allocator.alloc(); + curr->op = TruncSatSFloat32ToInt32; + break; + case BinaryConsts::I32UTruncSatF32: + curr = allocator.alloc(); + curr->op = TruncSatUFloat32ToInt32; + break; + case BinaryConsts::I32STruncSatF64: + curr = allocator.alloc(); + curr->op = TruncSatSFloat64ToInt32; + break; + case BinaryConsts::I32UTruncSatF64: + curr = allocator.alloc(); + curr->op = TruncSatUFloat64ToInt32; + break; + case BinaryConsts::I64STruncSatF32: + curr = allocator.alloc(); + curr->op = TruncSatSFloat32ToInt64; + break; + case BinaryConsts::I64UTruncSatF32: + curr = allocator.alloc(); + curr->op = TruncSatUFloat32ToInt64; + break; + case BinaryConsts::I64STruncSatF64: + curr = allocator.alloc(); + curr->op = TruncSatSFloat64ToInt64; + break; + case BinaryConsts::I64UTruncSatF64: + curr = allocator.alloc(); + curr->op = TruncSatUFloat64ToInt64; + break; + default: + return false; + } + BYN_TRACE("zz node: Unary (nontrapping float-to-int)\n"); + curr->value = popNonVoidExpression(); + curr->finalize(); + out = curr; + return true; +} + +bool WasmBinaryBuilder::maybeVisitMemoryInit(Expression*& out, uint32_t code) { + if (code != BinaryConsts::MemoryInit) { + return false; + } + auto* curr = allocator.alloc(); + curr->size = popNonVoidExpression(); + curr->offset = popNonVoidExpression(); + curr->dest = popNonVoidExpression(); + curr->segment = getU32LEB(); + if (getInt8() != 0) { + throwError("Unexpected nonzero memory index"); + } + curr->finalize(); + out = curr; + return true; +} + +bool WasmBinaryBuilder::maybeVisitDataDrop(Expression*& out, uint32_t code) { + if (code != BinaryConsts::DataDrop) { + return false; + } + auto* curr = allocator.alloc(); + curr->segment = getU32LEB(); + curr->finalize(); + out = curr; + return true; +} + +bool WasmBinaryBuilder::maybeVisitMemoryCopy(Expression*& out, uint32_t code) { + if (code != BinaryConsts::MemoryCopy) { + return false; + } + auto* curr = allocator.alloc(); + curr->size = popNonVoidExpression(); + curr->source = popNonVoidExpression(); + curr->dest = popNonVoidExpression(); + if (getInt8() != 0 || getInt8() != 0) { + throwError("Unexpected nonzero memory index"); + } + curr->finalize(); + out = curr; + return true; +} + +bool WasmBinaryBuilder::maybeVisitMemoryFill(Expression*& out, uint32_t code) { + if (code != BinaryConsts::MemoryFill) { + return false; + } + auto* curr = allocator.alloc(); + curr->size = popNonVoidExpression(); + curr->value = popNonVoidExpression(); + curr->dest = popNonVoidExpression(); + if (getInt8() != 0) { + throwError("Unexpected nonzero memory index"); + } + curr->finalize(); + out = curr; + return true; +} + +bool WasmBinaryBuilder::maybeVisitBinary(Expression*& out, uint8_t code) { + Binary* curr; +#define INT_TYPED_CODE(code) \ + { \ + case BinaryConsts::I32##code: \ + curr = allocator.alloc(); \ + curr->op = code##Int32; \ + break; \ + case BinaryConsts::I64##code: \ + curr = allocator.alloc(); \ + curr->op = code##Int64; \ + break; \ + } +#define FLOAT_TYPED_CODE(code) \ + { \ + case BinaryConsts::F32##code: \ + curr = allocator.alloc(); \ + curr->op = code##Float32; \ + break; \ + case BinaryConsts::F64##code: \ + curr = allocator.alloc(); \ + curr->op = code##Float64; \ + break; \ + } +#define TYPED_CODE(code) \ + { \ + INT_TYPED_CODE(code) \ + FLOAT_TYPED_CODE(code) \ + } + + switch (code) { + TYPED_CODE(Add); + TYPED_CODE(Sub); + TYPED_CODE(Mul); + INT_TYPED_CODE(DivS); + INT_TYPED_CODE(DivU); + INT_TYPED_CODE(RemS); + INT_TYPED_CODE(RemU); + INT_TYPED_CODE(And); + INT_TYPED_CODE(Or); + INT_TYPED_CODE(Xor); + INT_TYPED_CODE(Shl); + INT_TYPED_CODE(ShrU); + INT_TYPED_CODE(ShrS); + INT_TYPED_CODE(RotL); + INT_TYPED_CODE(RotR); + FLOAT_TYPED_CODE(Div); + FLOAT_TYPED_CODE(CopySign); + FLOAT_TYPED_CODE(Min); + FLOAT_TYPED_CODE(Max); + TYPED_CODE(Eq); + TYPED_CODE(Ne); + INT_TYPED_CODE(LtS); + INT_TYPED_CODE(LtU); + INT_TYPED_CODE(LeS); + INT_TYPED_CODE(LeU); + INT_TYPED_CODE(GtS); + INT_TYPED_CODE(GtU); + INT_TYPED_CODE(GeS); + INT_TYPED_CODE(GeU); + FLOAT_TYPED_CODE(Lt); + FLOAT_TYPED_CODE(Le); + FLOAT_TYPED_CODE(Gt); + FLOAT_TYPED_CODE(Ge); + default: + return false; + } + BYN_TRACE("zz node: Binary\n"); + curr->right = popNonVoidExpression(); + curr->left = popNonVoidExpression(); + curr->finalize(); + out = curr; + return true; +#undef TYPED_CODE +#undef INT_TYPED_CODE +#undef FLOAT_TYPED_CODE +} + +bool WasmBinaryBuilder::maybeVisitSIMDBinary(Expression*& out, uint32_t code) { + Binary* curr; + switch (code) { + case BinaryConsts::I8x16Eq: + curr = allocator.alloc(); + curr->op = EqVecI8x16; + break; + case BinaryConsts::I8x16Ne: + curr = allocator.alloc(); + curr->op = NeVecI8x16; + break; + case BinaryConsts::I8x16LtS: + curr = allocator.alloc(); + curr->op = LtSVecI8x16; + break; + case BinaryConsts::I8x16LtU: + curr = allocator.alloc(); + curr->op = LtUVecI8x16; + break; + case BinaryConsts::I8x16GtS: + curr = allocator.alloc(); + curr->op = GtSVecI8x16; + break; + case BinaryConsts::I8x16GtU: + curr = allocator.alloc(); + curr->op = GtUVecI8x16; + break; + case BinaryConsts::I8x16LeS: + curr = allocator.alloc(); + curr->op = LeSVecI8x16; + break; + case BinaryConsts::I8x16LeU: + curr = allocator.alloc(); + curr->op = LeUVecI8x16; + break; + case BinaryConsts::I8x16GeS: + curr = allocator.alloc(); + curr->op = GeSVecI8x16; + break; + case BinaryConsts::I8x16GeU: + curr = allocator.alloc(); + curr->op = GeUVecI8x16; + break; + case BinaryConsts::I16x8Eq: + curr = allocator.alloc(); + curr->op = EqVecI16x8; + break; + case BinaryConsts::I16x8Ne: + curr = allocator.alloc(); + curr->op = NeVecI16x8; + break; + case BinaryConsts::I16x8LtS: + curr = allocator.alloc(); + curr->op = LtSVecI16x8; + break; + case BinaryConsts::I16x8LtU: + curr = allocator.alloc(); + curr->op = LtUVecI16x8; + break; + case BinaryConsts::I16x8GtS: + curr = allocator.alloc(); + curr->op = GtSVecI16x8; + break; + case BinaryConsts::I16x8GtU: + curr = allocator.alloc(); + curr->op = GtUVecI16x8; + break; + case BinaryConsts::I16x8LeS: + curr = allocator.alloc(); + curr->op = LeSVecI16x8; + break; + case BinaryConsts::I16x8LeU: + curr = allocator.alloc(); + curr->op = LeUVecI16x8; + break; + case BinaryConsts::I16x8GeS: + curr = allocator.alloc(); + curr->op = GeSVecI16x8; + break; + case BinaryConsts::I16x8GeU: + curr = allocator.alloc(); + curr->op = GeUVecI16x8; + break; + case BinaryConsts::I32x4Eq: + curr = allocator.alloc(); + curr->op = EqVecI32x4; + break; + case BinaryConsts::I32x4Ne: + curr = allocator.alloc(); + curr->op = NeVecI32x4; + break; + case BinaryConsts::I32x4LtS: + curr = allocator.alloc(); + curr->op = LtSVecI32x4; + break; + case BinaryConsts::I32x4LtU: + curr = allocator.alloc(); + curr->op = LtUVecI32x4; + break; + case BinaryConsts::I32x4GtS: + curr = allocator.alloc(); + curr->op = GtSVecI32x4; + break; + case BinaryConsts::I32x4GtU: + curr = allocator.alloc(); + curr->op = GtUVecI32x4; + break; + case BinaryConsts::I32x4LeS: + curr = allocator.alloc(); + curr->op = LeSVecI32x4; + break; + case BinaryConsts::I32x4LeU: + curr = allocator.alloc(); + curr->op = LeUVecI32x4; + break; + case BinaryConsts::I32x4GeS: + curr = allocator.alloc(); + curr->op = GeSVecI32x4; + break; + case BinaryConsts::I32x4GeU: + curr = allocator.alloc(); + curr->op = GeUVecI32x4; + break; + case BinaryConsts::F32x4Eq: + curr = allocator.alloc(); + curr->op = EqVecF32x4; + break; + case BinaryConsts::F32x4Ne: + curr = allocator.alloc(); + curr->op = NeVecF32x4; + break; + case BinaryConsts::F32x4Lt: + curr = allocator.alloc(); + curr->op = LtVecF32x4; + break; + case BinaryConsts::F32x4Gt: + curr = allocator.alloc(); + curr->op = GtVecF32x4; + break; + case BinaryConsts::F32x4Le: + curr = allocator.alloc(); + curr->op = LeVecF32x4; + break; + case BinaryConsts::F32x4Ge: + curr = allocator.alloc(); + curr->op = GeVecF32x4; + break; + case BinaryConsts::F64x2Eq: + curr = allocator.alloc(); + curr->op = EqVecF64x2; + break; + case BinaryConsts::F64x2Ne: + curr = allocator.alloc(); + curr->op = NeVecF64x2; + break; + case BinaryConsts::F64x2Lt: + curr = allocator.alloc(); + curr->op = LtVecF64x2; + break; + case BinaryConsts::F64x2Gt: + curr = allocator.alloc(); + curr->op = GtVecF64x2; + break; + case BinaryConsts::F64x2Le: + curr = allocator.alloc(); + curr->op = LeVecF64x2; + break; + case BinaryConsts::F64x2Ge: + curr = allocator.alloc(); + curr->op = GeVecF64x2; + break; + case BinaryConsts::V128And: + curr = allocator.alloc(); + curr->op = AndVec128; + break; + case BinaryConsts::V128Or: + curr = allocator.alloc(); + curr->op = OrVec128; + break; + case BinaryConsts::V128Xor: + curr = allocator.alloc(); + curr->op = XorVec128; + break; + case BinaryConsts::V128AndNot: + curr = allocator.alloc(); + curr->op = AndNotVec128; + break; + case BinaryConsts::I8x16Add: + curr = allocator.alloc(); + curr->op = AddVecI8x16; + break; + case BinaryConsts::I8x16AddSatS: + curr = allocator.alloc(); + curr->op = AddSatSVecI8x16; + break; + case BinaryConsts::I8x16AddSatU: + curr = allocator.alloc(); + curr->op = AddSatUVecI8x16; + break; + case BinaryConsts::I8x16Sub: + curr = allocator.alloc(); + curr->op = SubVecI8x16; + break; + case BinaryConsts::I8x16SubSatS: + curr = allocator.alloc(); + curr->op = SubSatSVecI8x16; + break; + case BinaryConsts::I8x16SubSatU: + curr = allocator.alloc(); + curr->op = SubSatUVecI8x16; + break; + case BinaryConsts::I8x16Mul: + curr = allocator.alloc(); + curr->op = MulVecI8x16; + break; + case BinaryConsts::I8x16MinS: + curr = allocator.alloc(); + curr->op = MinSVecI8x16; + break; + case BinaryConsts::I8x16MinU: + curr = allocator.alloc(); + curr->op = MinUVecI8x16; + break; + case BinaryConsts::I8x16MaxS: + curr = allocator.alloc(); + curr->op = MaxSVecI8x16; + break; + case BinaryConsts::I8x16MaxU: + curr = allocator.alloc(); + curr->op = MaxUVecI8x16; + break; + case BinaryConsts::I8x16AvgrU: + curr = allocator.alloc(); + curr->op = AvgrUVecI8x16; + break; + case BinaryConsts::I16x8Add: + curr = allocator.alloc(); + curr->op = AddVecI16x8; + break; + case BinaryConsts::I16x8AddSatS: + curr = allocator.alloc(); + curr->op = AddSatSVecI16x8; + break; + case BinaryConsts::I16x8AddSatU: + curr = allocator.alloc(); + curr->op = AddSatUVecI16x8; + break; + case BinaryConsts::I16x8Sub: + curr = allocator.alloc(); + curr->op = SubVecI16x8; + break; + case BinaryConsts::I16x8SubSatS: + curr = allocator.alloc(); + curr->op = SubSatSVecI16x8; + break; + case BinaryConsts::I16x8SubSatU: + curr = allocator.alloc(); + curr->op = SubSatUVecI16x8; + break; + case BinaryConsts::I16x8Mul: + curr = allocator.alloc(); + curr->op = MulVecI16x8; + break; + case BinaryConsts::I16x8MinS: + curr = allocator.alloc(); + curr->op = MinSVecI16x8; + break; + case BinaryConsts::I16x8MinU: + curr = allocator.alloc(); + curr->op = MinUVecI16x8; + break; + case BinaryConsts::I16x8MaxS: + curr = allocator.alloc(); + curr->op = MaxSVecI16x8; + break; + case BinaryConsts::I16x8MaxU: + curr = allocator.alloc(); + curr->op = MaxUVecI16x8; + break; + case BinaryConsts::I16x8AvgrU: + curr = allocator.alloc(); + curr->op = AvgrUVecI16x8; + break; + case BinaryConsts::I32x4Add: + curr = allocator.alloc(); + curr->op = AddVecI32x4; + break; + case BinaryConsts::I32x4Sub: + curr = allocator.alloc(); + curr->op = SubVecI32x4; + break; + case BinaryConsts::I32x4Mul: + curr = allocator.alloc(); + curr->op = MulVecI32x4; + break; + case BinaryConsts::I32x4MinS: + curr = allocator.alloc(); + curr->op = MinSVecI32x4; + break; + case BinaryConsts::I32x4MinU: + curr = allocator.alloc(); + curr->op = MinUVecI32x4; + break; + case BinaryConsts::I32x4MaxS: + curr = allocator.alloc(); + curr->op = MaxSVecI32x4; + break; + case BinaryConsts::I32x4MaxU: + curr = allocator.alloc(); + curr->op = MaxUVecI32x4; + break; + case BinaryConsts::I32x4DotSVecI16x8: + curr = allocator.alloc(); + curr->op = DotSVecI16x8ToVecI32x4; + break; + case BinaryConsts::I64x2Add: + curr = allocator.alloc(); + curr->op = AddVecI64x2; + break; + case BinaryConsts::I64x2Sub: + curr = allocator.alloc(); + curr->op = SubVecI64x2; + break; + case BinaryConsts::I64x2Mul: + curr = allocator.alloc(); + curr->op = MulVecI64x2; + break; + case BinaryConsts::F32x4Add: + curr = allocator.alloc(); + curr->op = AddVecF32x4; + break; + case BinaryConsts::F32x4Sub: + curr = allocator.alloc(); + curr->op = SubVecF32x4; + break; + case BinaryConsts::F32x4Mul: + curr = allocator.alloc(); + curr->op = MulVecF32x4; + break; + case BinaryConsts::F32x4Div: + curr = allocator.alloc(); + curr->op = DivVecF32x4; + break; + case BinaryConsts::F32x4Min: + curr = allocator.alloc(); + curr->op = MinVecF32x4; + break; + case BinaryConsts::F32x4Max: + curr = allocator.alloc(); + curr->op = MaxVecF32x4; + break; + case BinaryConsts::F32x4PMin: + curr = allocator.alloc(); + curr->op = PMinVecF32x4; + break; + case BinaryConsts::F32x4PMax: + curr = allocator.alloc(); + curr->op = PMaxVecF32x4; + break; + case BinaryConsts::F64x2Add: + curr = allocator.alloc(); + curr->op = AddVecF64x2; + break; + case BinaryConsts::F64x2Sub: + curr = allocator.alloc(); + curr->op = SubVecF64x2; + break; + case BinaryConsts::F64x2Mul: + curr = allocator.alloc(); + curr->op = MulVecF64x2; + break; + case BinaryConsts::F64x2Div: + curr = allocator.alloc(); + curr->op = DivVecF64x2; + break; + case BinaryConsts::F64x2Min: + curr = allocator.alloc(); + curr->op = MinVecF64x2; + break; + case BinaryConsts::F64x2Max: + curr = allocator.alloc(); + curr->op = MaxVecF64x2; + break; + case BinaryConsts::F64x2PMin: + curr = allocator.alloc(); + curr->op = PMinVecF64x2; + break; + case BinaryConsts::F64x2PMax: + curr = allocator.alloc(); + curr->op = PMaxVecF64x2; + break; + case BinaryConsts::I8x16NarrowSI16x8: + curr = allocator.alloc(); + curr->op = NarrowSVecI16x8ToVecI8x16; + break; + case BinaryConsts::I8x16NarrowUI16x8: + curr = allocator.alloc(); + curr->op = NarrowUVecI16x8ToVecI8x16; + break; + case BinaryConsts::I16x8NarrowSI32x4: + curr = allocator.alloc(); + curr->op = NarrowSVecI32x4ToVecI16x8; + break; + case BinaryConsts::I16x8NarrowUI32x4: + curr = allocator.alloc(); + curr->op = NarrowUVecI32x4ToVecI16x8; + break; + case BinaryConsts::V8x16Swizzle: + curr = allocator.alloc(); + curr->op = SwizzleVec8x16; + break; + default: + return false; + } + BYN_TRACE("zz node: Binary\n"); + curr->right = popNonVoidExpression(); + curr->left = popNonVoidExpression(); + curr->finalize(); + out = curr; + return true; +} +bool WasmBinaryBuilder::maybeVisitSIMDUnary(Expression*& out, uint32_t code) { + Unary* curr; + switch (code) { + case BinaryConsts::I8x16Splat: + curr = allocator.alloc(); + curr->op = SplatVecI8x16; + break; + case BinaryConsts::I16x8Splat: + curr = allocator.alloc(); + curr->op = SplatVecI16x8; + break; + case BinaryConsts::I32x4Splat: + curr = allocator.alloc(); + curr->op = SplatVecI32x4; + break; + case BinaryConsts::I64x2Splat: + curr = allocator.alloc(); + curr->op = SplatVecI64x2; + break; + case BinaryConsts::F32x4Splat: + curr = allocator.alloc(); + curr->op = SplatVecF32x4; + break; + case BinaryConsts::F64x2Splat: + curr = allocator.alloc(); + curr->op = SplatVecF64x2; + break; + case BinaryConsts::V128Not: + curr = allocator.alloc(); + curr->op = NotVec128; + break; + case BinaryConsts::I8x16Abs: + curr = allocator.alloc(); + curr->op = AbsVecI8x16; + break; + case BinaryConsts::I8x16Neg: + curr = allocator.alloc(); + curr->op = NegVecI8x16; + break; + case BinaryConsts::I8x16AnyTrue: + curr = allocator.alloc(); + curr->op = AnyTrueVecI8x16; + break; + case BinaryConsts::I8x16AllTrue: + curr = allocator.alloc(); + curr->op = AllTrueVecI8x16; + break; + case BinaryConsts::I8x16Bitmask: + curr = allocator.alloc(); + curr->op = BitmaskVecI8x16; + break; + case BinaryConsts::I16x8Abs: + curr = allocator.alloc(); + curr->op = AbsVecI16x8; + break; + case BinaryConsts::I16x8Neg: + curr = allocator.alloc(); + curr->op = NegVecI16x8; + break; + case BinaryConsts::I16x8AnyTrue: + curr = allocator.alloc(); + curr->op = AnyTrueVecI16x8; + break; + case BinaryConsts::I16x8AllTrue: + curr = allocator.alloc(); + curr->op = AllTrueVecI16x8; + break; + case BinaryConsts::I16x8Bitmask: + curr = allocator.alloc(); + curr->op = BitmaskVecI16x8; + break; + case BinaryConsts::I32x4Abs: + curr = allocator.alloc(); + curr->op = AbsVecI32x4; + break; + case BinaryConsts::I32x4Neg: + curr = allocator.alloc(); + curr->op = NegVecI32x4; + break; + case BinaryConsts::I32x4AnyTrue: + curr = allocator.alloc(); + curr->op = AnyTrueVecI32x4; + break; + case BinaryConsts::I32x4AllTrue: + curr = allocator.alloc(); + curr->op = AllTrueVecI32x4; + break; + case BinaryConsts::I32x4Bitmask: + curr = allocator.alloc(); + curr->op = BitmaskVecI32x4; + break; + case BinaryConsts::I64x2Neg: + curr = allocator.alloc(); + curr->op = NegVecI64x2; + break; + case BinaryConsts::I64x2AnyTrue: + curr = allocator.alloc(); + curr->op = AnyTrueVecI64x2; + break; + case BinaryConsts::I64x2AllTrue: + curr = allocator.alloc(); + curr->op = AllTrueVecI64x2; + break; + case BinaryConsts::F32x4Abs: + curr = allocator.alloc(); + curr->op = AbsVecF32x4; + break; + case BinaryConsts::F32x4Neg: + curr = allocator.alloc(); + curr->op = NegVecF32x4; + break; + case BinaryConsts::F32x4Sqrt: + curr = allocator.alloc(); + curr->op = SqrtVecF32x4; + break; + case BinaryConsts::F32x4Ceil: + curr = allocator.alloc(); + curr->op = CeilVecF32x4; + break; + case BinaryConsts::F32x4Floor: + curr = allocator.alloc(); + curr->op = FloorVecF32x4; + break; + case BinaryConsts::F32x4Trunc: + curr = allocator.alloc(); + curr->op = TruncVecF32x4; + break; + case BinaryConsts::F32x4Nearest: + curr = allocator.alloc(); + curr->op = NearestVecF32x4; + break; + case BinaryConsts::F64x2Abs: + curr = allocator.alloc(); + curr->op = AbsVecF64x2; + break; + case BinaryConsts::F64x2Neg: + curr = allocator.alloc(); + curr->op = NegVecF64x2; + break; + case BinaryConsts::F64x2Sqrt: + curr = allocator.alloc(); + curr->op = SqrtVecF64x2; + break; + case BinaryConsts::F64x2Ceil: + curr = allocator.alloc(); + curr->op = CeilVecF64x2; + break; + case BinaryConsts::F64x2Floor: + curr = allocator.alloc(); + curr->op = FloorVecF64x2; + break; + case BinaryConsts::F64x2Trunc: + curr = allocator.alloc(); + curr->op = TruncVecF64x2; + break; + case BinaryConsts::F64x2Nearest: + curr = allocator.alloc(); + curr->op = NearestVecF64x2; + break; + case BinaryConsts::I32x4TruncSatSF32x4: + curr = allocator.alloc(); + curr->op = TruncSatSVecF32x4ToVecI32x4; + break; + case BinaryConsts::I32x4TruncSatUF32x4: + curr = allocator.alloc(); + curr->op = TruncSatUVecF32x4ToVecI32x4; + break; + case BinaryConsts::I64x2TruncSatSF64x2: + curr = allocator.alloc(); + curr->op = TruncSatSVecF64x2ToVecI64x2; + break; + case BinaryConsts::I64x2TruncSatUF64x2: + curr = allocator.alloc(); + curr->op = TruncSatUVecF64x2ToVecI64x2; + break; + case BinaryConsts::F32x4ConvertSI32x4: + curr = allocator.alloc(); + curr->op = ConvertSVecI32x4ToVecF32x4; + break; + case BinaryConsts::F32x4ConvertUI32x4: + curr = allocator.alloc(); + curr->op = ConvertUVecI32x4ToVecF32x4; + break; + case BinaryConsts::F64x2ConvertSI64x2: + curr = allocator.alloc(); + curr->op = ConvertSVecI64x2ToVecF64x2; + break; + case BinaryConsts::F64x2ConvertUI64x2: + curr = allocator.alloc(); + curr->op = ConvertUVecI64x2ToVecF64x2; + break; + case BinaryConsts::I16x8WidenLowSI8x16: + curr = allocator.alloc(); + curr->op = WidenLowSVecI8x16ToVecI16x8; + break; + case BinaryConsts::I16x8WidenHighSI8x16: + curr = allocator.alloc(); + curr->op = WidenHighSVecI8x16ToVecI16x8; + break; + case BinaryConsts::I16x8WidenLowUI8x16: + curr = allocator.alloc(); + curr->op = WidenLowUVecI8x16ToVecI16x8; + break; + case BinaryConsts::I16x8WidenHighUI8x16: + curr = allocator.alloc(); + curr->op = WidenHighUVecI8x16ToVecI16x8; + break; + case BinaryConsts::I32x4WidenLowSI16x8: + curr = allocator.alloc(); + curr->op = WidenLowSVecI16x8ToVecI32x4; + break; + case BinaryConsts::I32x4WidenHighSI16x8: + curr = allocator.alloc(); + curr->op = WidenHighSVecI16x8ToVecI32x4; + break; + case BinaryConsts::I32x4WidenLowUI16x8: + curr = allocator.alloc(); + curr->op = WidenLowUVecI16x8ToVecI32x4; + break; + case BinaryConsts::I32x4WidenHighUI16x8: + curr = allocator.alloc(); + curr->op = WidenHighUVecI16x8ToVecI32x4; + break; + default: + return false; + } + curr->value = popNonVoidExpression(); + curr->finalize(); + out = curr; + return true; +} + +bool WasmBinaryBuilder::maybeVisitSIMDConst(Expression*& out, uint32_t code) { + if (code != BinaryConsts::V128Const) { + return false; + } + auto* curr = allocator.alloc(); + curr->value = getVec128Literal(); + curr->finalize(); + out = curr; + return true; +} + +bool WasmBinaryBuilder::maybeVisitSIMDStore(Expression*& out, uint32_t code) { + if (code != BinaryConsts::V128Store) { + return false; + } + auto* curr = allocator.alloc(); + curr->bytes = 16; + curr->valueType = Type::v128; + readMemoryAccess(curr->align, curr->offset); + curr->isAtomic = false; + curr->value = popNonVoidExpression(); + curr->ptr = popNonVoidExpression(); + curr->finalize(); + out = curr; + return true; +} + +bool WasmBinaryBuilder::maybeVisitSIMDExtract(Expression*& out, uint32_t code) { + SIMDExtract* curr; + switch (code) { + case BinaryConsts::I8x16ExtractLaneS: + curr = allocator.alloc(); + curr->op = ExtractLaneSVecI8x16; + curr->index = getLaneIndex(16); + break; + case BinaryConsts::I8x16ExtractLaneU: + curr = allocator.alloc(); + curr->op = ExtractLaneUVecI8x16; + curr->index = getLaneIndex(16); + break; + case BinaryConsts::I16x8ExtractLaneS: + curr = allocator.alloc(); + curr->op = ExtractLaneSVecI16x8; + curr->index = getLaneIndex(8); + break; + case BinaryConsts::I16x8ExtractLaneU: + curr = allocator.alloc(); + curr->op = ExtractLaneUVecI16x8; + curr->index = getLaneIndex(8); + break; + case BinaryConsts::I32x4ExtractLane: + curr = allocator.alloc(); + curr->op = ExtractLaneVecI32x4; + curr->index = getLaneIndex(4); + break; + case BinaryConsts::I64x2ExtractLane: + curr = allocator.alloc(); + curr->op = ExtractLaneVecI64x2; + curr->index = getLaneIndex(2); + break; + case BinaryConsts::F32x4ExtractLane: + curr = allocator.alloc(); + curr->op = ExtractLaneVecF32x4; + curr->index = getLaneIndex(4); + break; + case BinaryConsts::F64x2ExtractLane: + curr = allocator.alloc(); + curr->op = ExtractLaneVecF64x2; + curr->index = getLaneIndex(2); + break; + default: + return false; + } + curr->vec = popNonVoidExpression(); + curr->finalize(); + out = curr; + return true; +} + +bool WasmBinaryBuilder::maybeVisitSIMDReplace(Expression*& out, uint32_t code) { + SIMDReplace* curr; + switch (code) { + case BinaryConsts::I8x16ReplaceLane: + curr = allocator.alloc(); + curr->op = ReplaceLaneVecI8x16; + curr->index = getLaneIndex(16); + break; + case BinaryConsts::I16x8ReplaceLane: + curr = allocator.alloc(); + curr->op = ReplaceLaneVecI16x8; + curr->index = getLaneIndex(8); + break; + case BinaryConsts::I32x4ReplaceLane: + curr = allocator.alloc(); + curr->op = ReplaceLaneVecI32x4; + curr->index = getLaneIndex(4); + break; + case BinaryConsts::I64x2ReplaceLane: + curr = allocator.alloc(); + curr->op = ReplaceLaneVecI64x2; + curr->index = getLaneIndex(2); + break; + case BinaryConsts::F32x4ReplaceLane: + curr = allocator.alloc(); + curr->op = ReplaceLaneVecF32x4; + curr->index = getLaneIndex(4); + break; + case BinaryConsts::F64x2ReplaceLane: + curr = allocator.alloc(); + curr->op = ReplaceLaneVecF64x2; + curr->index = getLaneIndex(2); + break; + default: + return false; + } + curr->value = popNonVoidExpression(); + curr->vec = popNonVoidExpression(); + curr->finalize(); + out = curr; + return true; +} + +bool WasmBinaryBuilder::maybeVisitSIMDShuffle(Expression*& out, uint32_t code) { + if (code != BinaryConsts::V8x16Shuffle) { + return false; + } + auto* curr = allocator.alloc(); + for (auto i = 0; i < 16; ++i) { + curr->mask[i] = getLaneIndex(32); + } + curr->right = popNonVoidExpression(); + curr->left = popNonVoidExpression(); + curr->finalize(); + out = curr; + return true; +} + +bool WasmBinaryBuilder::maybeVisitSIMDTernary(Expression*& out, uint32_t code) { + SIMDTernary* curr; + switch (code) { + case BinaryConsts::V128Bitselect: + curr = allocator.alloc(); + curr->op = Bitselect; + break; + case BinaryConsts::F32x4QFMA: + curr = allocator.alloc(); + curr->op = QFMAF32x4; + break; + case BinaryConsts::F32x4QFMS: + curr = allocator.alloc(); + curr->op = QFMSF32x4; + break; + case BinaryConsts::F64x2QFMA: + curr = allocator.alloc(); + curr->op = QFMAF64x2; + break; + case BinaryConsts::F64x2QFMS: + curr = allocator.alloc(); + curr->op = QFMSF64x2; + break; + default: + return false; + } + curr->c = popNonVoidExpression(); + curr->b = popNonVoidExpression(); + curr->a = popNonVoidExpression(); + curr->finalize(); + out = curr; + return true; +} + +bool WasmBinaryBuilder::maybeVisitSIMDShift(Expression*& out, uint32_t code) { + SIMDShift* curr; + switch (code) { + case BinaryConsts::I8x16Shl: + curr = allocator.alloc(); + curr->op = ShlVecI8x16; + break; + case BinaryConsts::I8x16ShrS: + curr = allocator.alloc(); + curr->op = ShrSVecI8x16; + break; + case BinaryConsts::I8x16ShrU: + curr = allocator.alloc(); + curr->op = ShrUVecI8x16; + break; + case BinaryConsts::I16x8Shl: + curr = allocator.alloc(); + curr->op = ShlVecI16x8; + break; + case BinaryConsts::I16x8ShrS: + curr = allocator.alloc(); + curr->op = ShrSVecI16x8; + break; + case BinaryConsts::I16x8ShrU: + curr = allocator.alloc(); + curr->op = ShrUVecI16x8; + break; + case BinaryConsts::I32x4Shl: + curr = allocator.alloc(); + curr->op = ShlVecI32x4; + break; + case BinaryConsts::I32x4ShrS: + curr = allocator.alloc(); + curr->op = ShrSVecI32x4; + break; + case BinaryConsts::I32x4ShrU: + curr = allocator.alloc(); + curr->op = ShrUVecI32x4; + break; + case BinaryConsts::I64x2Shl: + curr = allocator.alloc(); + curr->op = ShlVecI64x2; + break; + case BinaryConsts::I64x2ShrS: + curr = allocator.alloc(); + curr->op = ShrSVecI64x2; + break; + case BinaryConsts::I64x2ShrU: + curr = allocator.alloc(); + curr->op = ShrUVecI64x2; + break; + default: + return false; + } + curr->shift = popNonVoidExpression(); + curr->vec = popNonVoidExpression(); + curr->finalize(); + out = curr; + return true; +} + +bool WasmBinaryBuilder::maybeVisitSIMDLoad(Expression*& out, uint32_t code) { + if (code == BinaryConsts::V128Load) { + auto* curr = allocator.alloc(); + curr->type = Type::v128; + curr->bytes = 16; + readMemoryAccess(curr->align, curr->offset); + curr->isAtomic = false; + curr->ptr = popNonVoidExpression(); + curr->finalize(); + out = curr; + return true; + } + SIMDLoad* curr; + switch (code) { + case BinaryConsts::V8x16LoadSplat: + curr = allocator.alloc(); + curr->op = LoadSplatVec8x16; + break; + case BinaryConsts::V16x8LoadSplat: + curr = allocator.alloc(); + curr->op = LoadSplatVec16x8; + break; + case BinaryConsts::V32x4LoadSplat: + curr = allocator.alloc(); + curr->op = LoadSplatVec32x4; + break; + case BinaryConsts::V64x2LoadSplat: + curr = allocator.alloc(); + curr->op = LoadSplatVec64x2; + break; + case BinaryConsts::I16x8LoadExtSVec8x8: + curr = allocator.alloc(); + curr->op = LoadExtSVec8x8ToVecI16x8; + break; + case BinaryConsts::I16x8LoadExtUVec8x8: + curr = allocator.alloc(); + curr->op = LoadExtUVec8x8ToVecI16x8; + break; + case BinaryConsts::I32x4LoadExtSVec16x4: + curr = allocator.alloc(); + curr->op = LoadExtSVec16x4ToVecI32x4; + break; + case BinaryConsts::I32x4LoadExtUVec16x4: + curr = allocator.alloc(); + curr->op = LoadExtUVec16x4ToVecI32x4; + break; + case BinaryConsts::I64x2LoadExtSVec32x2: + curr = allocator.alloc(); + curr->op = LoadExtSVec32x2ToVecI64x2; + break; + case BinaryConsts::I64x2LoadExtUVec32x2: + curr = allocator.alloc(); + curr->op = LoadExtUVec32x2ToVecI64x2; + break; + case BinaryConsts::V128Load32Zero: + curr = allocator.alloc(); + curr->op = Load32Zero; + break; + case BinaryConsts::V128Load64Zero: + curr = allocator.alloc(); + curr->op = Load64Zero; + break; + default: + return false; + } + readMemoryAccess(curr->align, curr->offset); + curr->ptr = popNonVoidExpression(); + curr->finalize(); + out = curr; + return true; +} + +void WasmBinaryBuilder::visitSelect(Select* curr, uint8_t code) { + BYN_TRACE("zz node: Select, code " << int32_t(code) << std::endl); + if (code == BinaryConsts::SelectWithType) { + size_t numTypes = getU32LEB(); + std::vector types; + for (size_t i = 0; i < numTypes; i++) { + types.push_back(getType()); + } + curr->type = Type(types); + } + curr->condition = popNonVoidExpression(); + curr->ifFalse = popNonVoidExpression(); + curr->ifTrue = popNonVoidExpression(); + if (code == BinaryConsts::SelectWithType) { + curr->finalize(curr->type); + } else { + curr->finalize(); + } +} + +void WasmBinaryBuilder::visitReturn(Return* curr) { + BYN_TRACE("zz node: Return\n"); + requireFunctionContext("return"); + if (currFunction->sig.results.isConcrete()) { + curr->value = popTypedExpression(currFunction->sig.results); + } + curr->finalize(); +} + +void WasmBinaryBuilder::visitMemorySize(MemorySize* curr) { + BYN_TRACE("zz node: MemorySize\n"); + auto reserved = getU32LEB(); + if (reserved != 0) { + throwError("Invalid reserved field on memory.size"); + } + curr->finalize(); +} + +void WasmBinaryBuilder::visitMemoryGrow(MemoryGrow* curr) { + BYN_TRACE("zz node: MemoryGrow\n"); + curr->delta = popNonVoidExpression(); + auto reserved = getU32LEB(); + if (reserved != 0) { + throwError("Invalid reserved field on memory.grow"); + } + curr->finalize(); +} + +void WasmBinaryBuilder::visitNop(Nop* curr) { BYN_TRACE("zz node: Nop\n"); } + +void WasmBinaryBuilder::visitUnreachable(Unreachable* curr) { + BYN_TRACE("zz node: Unreachable\n"); +} + +void WasmBinaryBuilder::visitDrop(Drop* curr) { + BYN_TRACE("zz node: Drop\n"); + curr->value = popNonVoidExpression(); + curr->finalize(); +} + +void WasmBinaryBuilder::visitRefNull(RefNull* curr) { + BYN_TRACE("zz node: RefNull\n"); + curr->finalize(getHeapType()); +} + +void WasmBinaryBuilder::visitRefIsNull(RefIsNull* curr) { + BYN_TRACE("zz node: RefIsNull\n"); + curr->value = popNonVoidExpression(); + curr->finalize(); +} + +void WasmBinaryBuilder::visitRefFunc(RefFunc* curr) { + BYN_TRACE("zz node: RefFunc\n"); + Index index = getU32LEB(); + if (index >= functionImports.size() + functionSignatures.size()) { + throwError("ref.func: invalid call index"); + } + functionRefs[index].push_back(curr); // we don't know function names yet + curr->finalize(); +} + +void WasmBinaryBuilder::visitRefEq(RefEq* curr) { + BYN_TRACE("zz node: RefEq\n"); + curr->right = popNonVoidExpression(); + curr->left = popNonVoidExpression(); + curr->finalize(); +} + +void WasmBinaryBuilder::visitTryOrTryInBlock(Expression*& out) { + BYN_TRACE("zz node: Try\n"); + auto* curr = allocator.alloc(); + startControlFlow(curr); + // For simplicity of implementation, like if scopes, we create a hidden block + // within each try-body and catch-body, and let branches target those inner + // blocks instead. + curr->type = getType(); + curr->body = getBlockOrSingleton(curr->type); + if (lastSeparator != BinaryConsts::Catch) { + throwError("No catch instruction within a try scope"); + } + + // For simplicity, we create an inner block within the catch body too, but the + // one within the 'catch' *must* be omitted when we write out the binary back + // later, because the 'catch' instruction pushes a value onto the stack and + // the inner block does not support block input parameters without multivalue + // support. + // try + // ... + // catch ;; Pushes a value onto the stack + // block ;; Inner block. Should be deleted when writing binary! + // use the pushed value + // end + // end + // + // But when input binary code is like + // try + // ... + // catch + // br 0 + // end + // + // 'br 0' accidentally happens to target the inner block, creating code like + // this in Binaryen IR, making the inner block not deletable, resulting in a + // validation error: + // (try + // ... + // (catch + // (block $label0 ;; Cannot be deleted, because there's a branch to this + // ... + // (br $label0) + // ) + // ) + // ) + // + // When this happens, we fix this by creating a block that wraps the whole + // try-catch, and making the branches target that block instead, like this: + // (block $label ;; New enclosing block, new target for the branch + // (try + // ... + // (catch + // (block ;; Now this can be deleted when writing binary + // ... + // (br $label0) + // ) + // ) + // ) + // ) + Name catchLabel = getNextLabel(); + breakStack.push_back({catchLabel, curr->type}); + auto start = expressionStack.size(); + + Builder builder(wasm); + pushExpression(builder.makePop(Type::exnref)); + + processExpressions(); + size_t end = expressionStack.size(); + if (start > end) { + throwError("block cannot pop from outside"); + } + if (end - start == 1) { + curr->catchBody = popExpression(); + } else { + auto* block = allocator.alloc(); + pushBlockElements(block, curr->type, start); + block->finalize(curr->type); + curr->catchBody = block; + } + curr->finalize(curr->type); + + if (breakTargetNames.find(catchLabel) == breakTargetNames.end()) { + out = curr; + } else { + // Create a new block that encloses the whole try-catch + auto* block = builder.makeBlock(catchLabel, curr); + out = block; + } + breakStack.pop_back(); + breakTargetNames.erase(catchLabel); +} + +void WasmBinaryBuilder::visitThrow(Throw* curr) { + BYN_TRACE("zz node: Throw\n"); + auto index = getU32LEB(); + if (index >= wasm.events.size()) { + throwError("bad event index"); + } + auto* event = wasm.events[index].get(); + curr->event = event->name; + size_t num = event->sig.params.size(); + curr->operands.resize(num); + for (size_t i = 0; i < num; i++) { + curr->operands[num - i - 1] = popNonVoidExpression(); + } + curr->finalize(); +} + +void WasmBinaryBuilder::visitRethrow(Rethrow* curr) { + BYN_TRACE("zz node: Rethrow\n"); + curr->exnref = popNonVoidExpression(); + curr->finalize(); +} + +void WasmBinaryBuilder::visitBrOnExn(BrOnExn* curr) { + BYN_TRACE("zz node: BrOnExn\n"); + BreakTarget target = getBreakTarget(getU32LEB()); + curr->name = target.name; + auto index = getU32LEB(); + if (index >= wasm.events.size()) { + throwError("bad event index"); + } + curr->event = wasm.events[index]->name; + curr->exnref = popNonVoidExpression(); + + Event* event = wasm.getEventOrNull(curr->event); + assert(event && "br_on_exn's event must exist"); + + // Copy params info into BrOnExn, because it is necessary when BrOnExn is + // refinalized without the module. + curr->sent = event->sig.params; + curr->finalize(); +} + +bool WasmBinaryBuilder::maybeVisitI31New(Expression*& out, uint32_t code) { + if (code != BinaryConsts::I31New) { + return false; + } + auto* curr = allocator.alloc(); + curr->value = popNonVoidExpression(); + curr->finalize(); + out = curr; + return true; +} + +bool WasmBinaryBuilder::maybeVisitI31Get(Expression*& out, uint32_t code) { + I31Get* curr; + switch (code) { + case BinaryConsts::I31GetS: + curr = allocator.alloc(); + curr->signed_ = true; + break; + case BinaryConsts::I31GetU: + curr = allocator.alloc(); + curr->signed_ = false; + break; + default: + return false; + } + curr->i31 = popNonVoidExpression(); + curr->finalize(); + out = curr; + return true; +} + +bool WasmBinaryBuilder::maybeVisitRefTest(Expression*& out, uint32_t code) { + if (code != BinaryConsts::RefTest) { + return false; + } + auto* curr = allocator.alloc(); + WASM_UNREACHABLE("TODO (gc): ref.test"); + curr->finalize(); + out = curr; + return true; +} + +bool WasmBinaryBuilder::maybeVisitRefCast(Expression*& out, uint32_t code) { + if (code != BinaryConsts::RefCast) { + return false; + } + auto* curr = allocator.alloc(); + WASM_UNREACHABLE("TODO (gc): ref.cast"); + curr->finalize(); + out = curr; + return true; +} + +bool WasmBinaryBuilder::maybeVisitBrOnCast(Expression*& out, uint32_t code) { + if (code != BinaryConsts::BrOnCast) { + return false; + } + auto* curr = allocator.alloc(); + WASM_UNREACHABLE("TODO (gc): br_on_cast"); + curr->finalize(); + out = curr; + return true; +} + +bool WasmBinaryBuilder::maybeVisitRttCanon(Expression*& out, uint32_t code) { + if (code != BinaryConsts::RttCanon) { + return false; + } + auto* curr = allocator.alloc(); + WASM_UNREACHABLE("TODO (gc): rtt.canon"); + curr->finalize(); + out = curr; + return true; +} + +bool WasmBinaryBuilder::maybeVisitRttSub(Expression*& out, uint32_t code) { + if (code != BinaryConsts::RttSub) { + return false; + } + auto* curr = allocator.alloc(); + WASM_UNREACHABLE("TODO (gc): rtt.sub"); + curr->finalize(); + out = curr; + return true; +} + +bool WasmBinaryBuilder::maybeVisitStructNew(Expression*& out, uint32_t code) { + StructNew* curr; + switch (code) { + case BinaryConsts::StructNewWithRtt: + curr = allocator.alloc(); + // ... + break; + case BinaryConsts::StructNewDefaultWithRtt: + curr = allocator.alloc(); + // ... + break; + default: + return false; + } + WASM_UNREACHABLE("TODO (gc): struct.new"); + curr->finalize(); + out = curr; + return true; +} + +bool WasmBinaryBuilder::maybeVisitStructGet(Expression*& out, uint32_t code) { + StructGet* curr; + switch (code) { + case BinaryConsts::StructGet: + curr = allocator.alloc(); + // ... + break; + case BinaryConsts::StructGetS: + curr = allocator.alloc(); + // ... + break; + case BinaryConsts::StructGetU: + curr = allocator.alloc(); + // ... + break; + default: + return false; + } + WASM_UNREACHABLE("TODO (gc): struct.get"); + curr->finalize(); + out = curr; + return true; +} + +bool WasmBinaryBuilder::maybeVisitStructSet(Expression*& out, uint32_t code) { + if (code != BinaryConsts::StructSet) { + return false; + } + auto* curr = allocator.alloc(); + WASM_UNREACHABLE("TODO (gc): struct.set"); + curr->finalize(); + out = curr; + return true; +} + +bool WasmBinaryBuilder::maybeVisitArrayNew(Expression*& out, uint32_t code) { + ArrayNew* curr; + switch (code) { + case BinaryConsts::ArrayNewWithRtt: + curr = allocator.alloc(); + // ... + break; + case BinaryConsts::ArrayNewDefaultWithRtt: + curr = allocator.alloc(); + // ... + break; + default: + return false; + } + WASM_UNREACHABLE("TODO (gc): array.new"); + curr->finalize(); + out = curr; + return true; +} + +bool WasmBinaryBuilder::maybeVisitArrayGet(Expression*& out, uint32_t code) { + ArrayGet* curr; + switch (code) { + case BinaryConsts::ArrayGet: + curr = allocator.alloc(); + // ... + break; + case BinaryConsts::ArrayGetS: + curr = allocator.alloc(); + // ... + break; + case BinaryConsts::ArrayGetU: + curr = allocator.alloc(); + // ... + break; + default: + return false; + } + WASM_UNREACHABLE("TODO (gc): array.get"); + curr->finalize(); + out = curr; + return true; +} + +bool WasmBinaryBuilder::maybeVisitArraySet(Expression*& out, uint32_t code) { + if (code != BinaryConsts::ArraySet) { + return false; + } + auto* curr = allocator.alloc(); + WASM_UNREACHABLE("TODO (gc): array.set"); + curr->finalize(); + out = curr; + return true; +} + +bool WasmBinaryBuilder::maybeVisitArrayLen(Expression*& out, uint32_t code) { + if (code != BinaryConsts::ArrayLen) { + return false; + } + auto* curr = allocator.alloc(); + WASM_UNREACHABLE("TODO (gc): array.len"); + curr->finalize(); + out = curr; + return true; +} + +void WasmBinaryBuilder::throwError(std::string text) { + throw ParseException(text, 0, pos); +} + +} // namespace wasm diff --git a/binaryen/src/wasm/wasm-debug.cpp b/binaryen/src/wasm/wasm-debug.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/wasm/wasm-debug.cpp @@ -0,0 +1,1078 @@ +/* + * Copyright 2019 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "wasm-debug.h" +#include "wasm.h" + +#ifdef BUILD_LLVM_DWARF +#include "llvm/ObjectYAML/DWARFEmitter.h" +#include "llvm/ObjectYAML/DWARFYAML.h" +#include "llvm/include/llvm/DebugInfo/DWARFContext.h" + +std::error_code dwarf2yaml(llvm::DWARFContext& DCtx, llvm::DWARFYAML::Data& Y); +#endif + +#include "wasm-binary.h" +#include "wasm-debug.h" +#include "wasm.h" + +namespace wasm { + +namespace Debug { + +bool isDWARFSection(Name name) { return name.startsWith(".debug_"); } + +bool hasDWARFSections(const Module& wasm) { + for (auto& section : wasm.userSections) { + if (isDWARFSection(section.name)) { + return true; + } + } + return false; +} + +#ifdef BUILD_LLVM_DWARF + +// In wasm32 the address size is 32 bits. +static const size_t AddressSize = 4; + +struct BinaryenDWARFInfo { + llvm::StringMap> sections; + std::unique_ptr context; + + BinaryenDWARFInfo(const Module& wasm) { + // Get debug sections from the wasm. + for (auto& section : wasm.userSections) { + if (Name(section.name).startsWith(".debug_") && section.data.data()) { + // TODO: efficiency + sections[section.name.substr(1)] = llvm::MemoryBuffer::getMemBufferCopy( + llvm::StringRef(section.data.data(), section.data.size())); + } + } + // Parse debug sections. + uint8_t addrSize = AddressSize; + bool isLittleEndian = true; + context = llvm::DWARFContext::create(sections, addrSize, isLittleEndian); + } +}; + +void dumpDWARF(const Module& wasm) { + BinaryenDWARFInfo info(wasm); + std::cout << "DWARF debug info\n"; + std::cout << "================\n\n"; + for (auto& section : wasm.userSections) { + if (Name(section.name).startsWith(".debug_")) { + std::cout << "Contains section " << section.name << " (" + << section.data.size() << " bytes)\n"; + } + } + llvm::DIDumpOptions options; + options.DumpType = llvm::DIDT_All; + options.ShowChildren = true; + options.Verbose = true; + info.context->dump(llvm::outs(), options); +} + +// +// Big picture: We use a DWARFContext to read data, then DWARFYAML support +// code to write it. That is not the main LLVM Dwarf code used for writing +// object files, but it avoids us create a "fake" MC layer, and provides a +// simple way to write out the debug info. Likely the level of info represented +// in the DWARFYAML::Data object is sufficient for Binaryen's needs, but if not, +// we may need a different approach. +// +// In more detail: +// +// 1. Binary sections => DWARFContext: +// +// llvm::DWARFContext::create(sections..) +// +// 2. DWARFContext => DWARFYAML::Data +// +// std::error_code dwarf2yaml(DWARFContext &DCtx, DWARFYAML::Data &Y) { +// +// 3. DWARFYAML::Data => binary sections +// +// StringMap> +// EmitDebugSections(llvm::DWARFYAML::Data &DI, bool ApplyFixups); +// + +// Represents the state when parsing a line table. +struct LineState { + uint32_t addr = 0; + // TODO sectionIndex? + uint32_t line = 1; + uint32_t col = 0; + uint32_t file = 1; + uint32_t isa = 0; + uint32_t discriminator = 0; + bool isStmt; + bool basicBlock = false; + bool prologueEnd = false; + bool epilogueBegin = false; + // Each instruction is part of a sequence, all of which get the same ID. The + // order within a sequence may change if binaryen reorders things, which means + // that we can't track the end_sequence location and assume it is at the end - + // we must track sequences and then emit an end for each one. + // -1 is an invalid marker value (note that this assumes we can fit all ids + // into just under 32 bits). + uint32_t sequenceId = -1; + + LineState(const LineState& other) = default; + LineState(const llvm::DWARFYAML::LineTable& table, uint32_t sequenceId) + : isStmt(table.DefaultIsStmt), sequenceId(sequenceId) {} + + LineState& operator=(const LineState& other) = default; + + // Updates the state, and returns whether a new row is ready to be emitted. + bool update(llvm::DWARFYAML::LineTableOpcode& opcode, + const llvm::DWARFYAML::LineTable& table) { + switch (opcode.Opcode) { + case 0: { + // Extended opcodes + switch (opcode.SubOpcode) { + case llvm::dwarf::DW_LNE_set_address: { + addr = opcode.Data; + break; + } + case llvm::dwarf::DW_LNE_end_sequence: { + return true; + } + case llvm::dwarf::DW_LNE_set_discriminator: { + discriminator = opcode.Data; + break; + } + case llvm::dwarf::DW_LNE_define_file: { + Fatal() << "TODO: DW_LNE_define_file"; + } + default: { + // An unknown opcode, ignore. + std::cerr << "warning: unknown subopcopde " << opcode.SubOpcode + << '\n'; + } + } + break; + } + case llvm::dwarf::DW_LNS_set_column: { + col = opcode.Data; + break; + } + case llvm::dwarf::DW_LNS_set_prologue_end: { + prologueEnd = true; + break; + } + case llvm::dwarf::DW_LNS_copy: { + return true; + } + case llvm::dwarf::DW_LNS_advance_pc: { + assert(table.MinInstLength == 1); + addr += opcode.Data; + break; + } + case llvm::dwarf::DW_LNS_advance_line: { + line += opcode.SData; + break; + } + case llvm::dwarf::DW_LNS_set_file: { + file = opcode.Data; + break; + } + case llvm::dwarf::DW_LNS_negate_stmt: { + isStmt = !isStmt; + break; + } + case llvm::dwarf::DW_LNS_set_basic_block: { + basicBlock = true; + break; + } + case llvm::dwarf::DW_LNS_const_add_pc: { + uint8_t AdjustOpcode = 255 - table.OpcodeBase; + uint64_t AddrOffset = + (AdjustOpcode / table.LineRange) * table.MinInstLength; + addr += AddrOffset; + break; + } + case llvm::dwarf::DW_LNS_fixed_advance_pc: { + addr += opcode.Data; + break; + } + case llvm::dwarf::DW_LNS_set_isa: { + isa = opcode.Data; + break; + } + default: { + if (opcode.Opcode >= table.OpcodeBase) { + // Special opcode: adjust line and addr, using some math. + uint8_t AdjustOpcode = + opcode.Opcode - table.OpcodeBase; // 20 - 13 = 7 + uint64_t AddrOffset = (AdjustOpcode / table.LineRange) * + table.MinInstLength; // (7 / 14) * 1 = 0 + int32_t LineOffset = + table.LineBase + + (AdjustOpcode % table.LineRange); // -5 + (7 % 14) = 2 + line += LineOffset; + addr += AddrOffset; + return true; + } else { + Fatal() << "unknown debug line opcode: " << std::hex << opcode.Opcode; + } + } + } + return false; + } + + // Checks if this starts a new range of addresses. Each range is a set of + // related addresses, where in particular, if the first has been zeroed out + // by the linker, we must omit the entire range. (If we do not, then the + // initial range is 0 and the others are offsets relative to it, which will + // look like random addresses, perhaps into the middle of instructions, and + // perhaps that happen to collide with real ones.) + bool startsNewRange(llvm::DWARFYAML::LineTableOpcode& opcode) { + return opcode.Opcode == 0 && + opcode.SubOpcode == llvm::dwarf::DW_LNE_set_address; + } + + bool needToEmit() { + // Zero values imply we can ignore this line. + // https://github.com/WebAssembly/debugging/issues/9#issuecomment-567720872 + return line != 0 && addr != 0; + } + + // Given an old state, emit the diff from it to this state into a new line + // table entry (that will be emitted in the updated DWARF debug line section). + void emitDiff(const LineState& old, + std::vector& newOpcodes, + const llvm::DWARFYAML::LineTable& table, + bool endSequence) const { + bool useSpecial = false; + if (addr != old.addr || line != old.line) { + // Try to use a special opcode TODO + } + if (addr != old.addr && !useSpecial) { + // len = 1 (subopcode) + 4 (wasm32 address) + // FIXME: look at AddrSize on the Unit. + auto item = makeItem(llvm::dwarf::DW_LNE_set_address, 5); + item.Data = addr; + newOpcodes.push_back(item); + } + if (line != old.line && !useSpecial) { + auto item = makeItem(llvm::dwarf::DW_LNS_advance_line); + // In wasm32 we have 32-bit addresses, and the delta here might be + // negative (note that SData is 64-bit, as LLVM supports 64-bit + // addresses too). + item.SData = int32_t(line - old.line); + newOpcodes.push_back(item); + } + if (col != old.col) { + auto item = makeItem(llvm::dwarf::DW_LNS_set_column); + item.Data = col; + newOpcodes.push_back(item); + } + if (file != old.file) { + auto item = makeItem(llvm::dwarf::DW_LNS_set_file); + item.Data = file; + newOpcodes.push_back(item); + } + if (isa != old.isa) { + auto item = makeItem(llvm::dwarf::DW_LNS_set_isa); + item.Data = isa; + newOpcodes.push_back(item); + } + if (discriminator != old.discriminator) { + // len = 1 (subopcode) + 4 (wasm32 address) + auto item = makeItem(llvm::dwarf::DW_LNE_set_discriminator, 5); + item.Data = discriminator; + newOpcodes.push_back(item); + } + if (isStmt != old.isStmt) { + newOpcodes.push_back(makeItem(llvm::dwarf::DW_LNS_negate_stmt)); + } + if (basicBlock != old.basicBlock) { + assert(basicBlock); + newOpcodes.push_back(makeItem(llvm::dwarf::DW_LNS_set_basic_block)); + } + if (prologueEnd) { + newOpcodes.push_back(makeItem(llvm::dwarf::DW_LNS_set_prologue_end)); + } + if (epilogueBegin != old.epilogueBegin) { + Fatal() << "eb"; + } + if (useSpecial) { + // Emit a special, which emits a line automatically. + // TODO + } else { + // Emit the line manually. + if (endSequence) { + // len = 1 (subopcode) + newOpcodes.push_back(makeItem(llvm::dwarf::DW_LNE_end_sequence, 1)); + } else { + newOpcodes.push_back(makeItem(llvm::dwarf::DW_LNS_copy)); + } + } + } + + // Some flags are automatically reset after each debug line. + void resetAfterLine() { prologueEnd = false; } + +private: + llvm::DWARFYAML::LineTableOpcode + makeItem(llvm::dwarf::LineNumberOps opcode) const { + llvm::DWARFYAML::LineTableOpcode item = {}; + item.Opcode = opcode; + return item; + } + + llvm::DWARFYAML::LineTableOpcode + makeItem(llvm::dwarf::LineNumberExtendedOps opcode, uint64_t len) const { + auto item = makeItem(llvm::dwarf::LineNumberOps(0)); + // All the length after the len field itself, including the subopcode + // (1 byte). + item.ExtLen = len; + item.SubOpcode = opcode; + return item; + } +}; + +// Represents a mapping of addresses to expressions. We track beginnings and +// endings of expressions separately, since the end of one (which is one past +// the end in DWARF notation) overlaps with the beginning of the next, and also +// to let us use contextual information (we may know we are looking up the end +// of an instruction). +struct AddrExprMap { + std::unordered_map startMap; + std::unordered_map endMap; + + // Some instructions have delimiter binary locations, like the else and end in + // and if. Track those separately, including their expression and their id + // ("else", "end", etc.), as they are rare, and we don't want to + // bloat the common case which is represented in the earlier maps. + struct DelimiterInfo { + Expression* expr; + BinaryLocations::DelimiterId id; + }; + std::unordered_map delimiterMap; + + // Construct the map from the binaryLocations loaded from the wasm. + AddrExprMap(const Module& wasm) { + for (auto& func : wasm.functions) { + for (auto pair : func->expressionLocations) { + add(pair.first, pair.second); + } + for (auto pair : func->delimiterLocations) { + add(pair.first, pair.second); + } + } + } + + Expression* getStart(BinaryLocation addr) const { + auto iter = startMap.find(addr); + if (iter != startMap.end()) { + return iter->second; + } + return nullptr; + } + + Expression* getEnd(BinaryLocation addr) const { + auto iter = endMap.find(addr); + if (iter != endMap.end()) { + return iter->second; + } + return nullptr; + } + + DelimiterInfo getDelimiter(BinaryLocation addr) const { + auto iter = delimiterMap.find(addr); + if (iter != delimiterMap.end()) { + return iter->second; + } + return DelimiterInfo{nullptr, BinaryLocations::Invalid}; + } + +private: + void add(Expression* expr, const BinaryLocations::Span span) { + assert(startMap.count(span.start) == 0); + startMap[span.start] = expr; + assert(endMap.count(span.end) == 0); + endMap[span.end] = expr; + } + + void add(Expression* expr, + const BinaryLocations::DelimiterLocations& delimiter) { + for (Index i = 0; i < delimiter.size(); i++) { + if (delimiter[i] != 0) { + assert(delimiterMap.count(delimiter[i]) == 0); + delimiterMap[delimiter[i]] = + DelimiterInfo{expr, BinaryLocations::DelimiterId(i)}; + } + } + } +}; + +// Represents a mapping of addresses to expressions. As with expressions, we +// track both start and end; here, however, "start" means the "start" and +// "declarations" fields in FunctionLocations, and "end" means the two locations +// of one past the end, and one before it which is the "end" opcode that is +// emitted. +struct FuncAddrMap { + std::unordered_map startMap, endMap; + + // Construct the map from the binaryLocations loaded from the wasm. + FuncAddrMap(const Module& wasm) { + for (auto& func : wasm.functions) { + startMap[func->funcLocation.start] = func.get(); + startMap[func->funcLocation.declarations] = func.get(); + endMap[func->funcLocation.end - 1] = func.get(); + endMap[func->funcLocation.end] = func.get(); + } + } + + Function* getStart(BinaryLocation addr) const { + auto iter = startMap.find(addr); + if (iter != startMap.end()) { + return iter->second; + } + return nullptr; + } + + Function* getEnd(BinaryLocation addr) const { + auto iter = endMap.find(addr); + if (iter != endMap.end()) { + return iter->second; + } + return nullptr; + } +}; + +// Track locations from the original binary and the new one we wrote, so that +// we can update debug positions. +// We track expressions and functions separately, instead of having a single +// big map of (oldAddr) => (newAddr) because of the potentially ambiguous case +// of the final expression in a function: it's end might be identical in offset +// to the end of the function. So we have two different things that map to the +// same offset. However, if the context is "the end of the function" then the +// updated address is the new end of the function, even if the function ends +// with a different instruction now, as the old last instruction might have +// moved or been optimized out. +struct LocationUpdater { + Module& wasm; + const BinaryLocations& newLocations; + + AddrExprMap oldExprAddrMap; + FuncAddrMap oldFuncAddrMap; + + // Map offsets of location list entries in the debug_loc section to the index + // of their compile unit. + std::unordered_map locToUnitMap; + + // Map start of line tables in the debug_line section to their new locations. + std::unordered_map debugLineMap; + + typedef std::pair OldToNew; + + // Map of compile unit index => old and new base offsets (i.e., in the + // original binary and in the new one). + std::unordered_map compileUnitBases; + + // TODO: for memory efficiency, we may want to do this in a streaming manner, + // binary to binary, without YAML IR. + + LocationUpdater(Module& wasm, const BinaryLocations& newLocations) + : wasm(wasm), newLocations(newLocations), oldExprAddrMap(wasm), + oldFuncAddrMap(wasm) {} + + // Updates an expression's address. If there was never an instruction at that + // address, or if there was but if that instruction no longer exists, return + // 0. Otherwise, return the new updated location. + BinaryLocation getNewExprStart(BinaryLocation oldAddr) const { + if (auto* expr = oldExprAddrMap.getStart(oldAddr)) { + auto iter = newLocations.expressions.find(expr); + if (iter != newLocations.expressions.end()) { + BinaryLocation newAddr = iter->second.start; + return newAddr; + } + } + return 0; + } + + bool hasOldExprStart(BinaryLocation oldAddr) const { + return oldExprAddrMap.getStart(oldAddr); + } + + BinaryLocation getNewExprEnd(BinaryLocation oldAddr) const { + if (auto* expr = oldExprAddrMap.getEnd(oldAddr)) { + auto iter = newLocations.expressions.find(expr); + if (iter != newLocations.expressions.end()) { + return iter->second.end; + } + } + return 0; + } + + bool hasOldExprEnd(BinaryLocation oldAddr) const { + return oldExprAddrMap.getEnd(oldAddr); + } + + BinaryLocation getNewFuncStart(BinaryLocation oldAddr) const { + if (auto* func = oldFuncAddrMap.getStart(oldAddr)) { + // The function might have been optimized away, check. + auto iter = newLocations.functions.find(func); + if (iter != newLocations.functions.end()) { + auto oldLocations = func->funcLocation; + auto newLocations = iter->second; + if (oldAddr == oldLocations.start) { + return newLocations.start; + } else if (oldAddr == oldLocations.declarations) { + return newLocations.declarations; + } else { + WASM_UNREACHABLE("invalid func start"); + } + } + } + return 0; + } + + bool hasOldFuncStart(BinaryLocation oldAddr) const { + return oldFuncAddrMap.getStart(oldAddr); + } + + BinaryLocation getNewFuncEnd(BinaryLocation oldAddr) const { + if (auto* func = oldFuncAddrMap.getEnd(oldAddr)) { + // The function might have been optimized away, check. + auto iter = newLocations.functions.find(func); + if (iter != newLocations.functions.end()) { + auto oldLocations = func->funcLocation; + auto newLocations = iter->second; + if (oldAddr == oldLocations.end) { + return newLocations.end; + } else if (oldAddr == oldLocations.end - 1) { + return newLocations.end - 1; + } else { + WASM_UNREACHABLE("invalid func end"); + } + } + } + return 0; + } + + // Check for either the end opcode, or one past the end. + bool hasOldFuncEnd(BinaryLocation oldAddr) const { + return oldFuncAddrMap.getEnd(oldAddr); + } + + // Check specifically for the end opcode. + bool hasOldFuncEndOpcode(BinaryLocation oldAddr) const { + if (auto* func = oldFuncAddrMap.getEnd(oldAddr)) { + return oldAddr == func->funcLocation.end - 1; + } + return false; + } + + BinaryLocation getNewDelimiter(BinaryLocation oldAddr) const { + auto info = oldExprAddrMap.getDelimiter(oldAddr); + if (info.expr) { + auto iter = newLocations.delimiters.find(info.expr); + if (iter != newLocations.delimiters.end()) { + return iter->second[info.id]; + } + } + return 0; + } + + bool hasOldDelimiter(BinaryLocation oldAddr) const { + return oldExprAddrMap.getDelimiter(oldAddr).expr; + } + + // getNewStart|EndAddr utilities. + // TODO: should we track the start and end of delimiters, even though they + // are just one byte? + BinaryLocation getNewStart(BinaryLocation oldStart) const { + if (hasOldExprStart(oldStart)) { + return getNewExprStart(oldStart); + } else if (hasOldFuncStart(oldStart)) { + return getNewFuncStart(oldStart); + } else if (hasOldDelimiter(oldStart)) { + return getNewDelimiter(oldStart); + } + return 0; + } + + BinaryLocation getNewEnd(BinaryLocation oldEnd) const { + if (hasOldExprEnd(oldEnd)) { + return getNewExprEnd(oldEnd); + } else if (hasOldFuncEnd(oldEnd)) { + return getNewFuncEnd(oldEnd); + } else if (hasOldDelimiter(oldEnd)) { + return getNewDelimiter(oldEnd); + } + return 0; + } + + BinaryLocation getNewDebugLineLocation(BinaryLocation old) const { + return debugLineMap.at(old); + } + + // Given an offset in .debug_loc, get the old and new compile unit bases. + OldToNew getCompileUnitBasesForLoc(size_t offset) const { + auto index = locToUnitMap.at(offset); + auto iter = compileUnitBases.find(index); + if (iter != compileUnitBases.end()) { + return iter->second; + } + return OldToNew{0, 0}; + } +}; + +// Update debug lines, and update the locationUpdater with debug line offset +// changes so we can update offsets into the debug line section. +static void updateDebugLines(llvm::DWARFYAML::Data& data, + LocationUpdater& locationUpdater) { + for (auto& table : data.DebugLines) { + uint32_t sequenceId = 0; + // Parse the original opcodes and emit new ones. + LineState state(table, sequenceId); + // All the addresses we need to write out. + std::vector newAddrs; + std::unordered_map newAddrInfo; + // If the address was zeroed out, we must omit the entire range (we could + // also leave it unchanged, so that the debugger ignores it based on the + // initial zero; but it's easier and better to just not emit it at all). + bool omittingRange = false; + for (auto& opcode : table.Opcodes) { + // Update the state, and check if we have a new row to emit. + if (state.startsNewRange(opcode)) { + omittingRange = false; + } + if (state.update(opcode, table)) { + if (state.addr == 0) { + omittingRange = true; + } + if (omittingRange) { + state = LineState(table, sequenceId); + continue; + } + // An expression may not exist for this line table item, if we optimized + // it away. + BinaryLocation oldAddr = state.addr; + BinaryLocation newAddr = 0; + if (locationUpdater.hasOldExprStart(oldAddr)) { + newAddr = locationUpdater.getNewExprStart(oldAddr); + } + // Test for a function's end address first, as LLVM output appears to + // use 1-past-the-end-of-the-function as a location in that function, + // and not the next (but the first byte of the next function, which is + // ambiguously identical to that value, is used at least in low_pc). + else if (locationUpdater.hasOldFuncEnd(oldAddr)) { + newAddr = locationUpdater.getNewFuncEnd(oldAddr); + } else if (locationUpdater.hasOldFuncStart(oldAddr)) { + newAddr = locationUpdater.getNewFuncStart(oldAddr); + } else if (locationUpdater.hasOldDelimiter(oldAddr)) { + newAddr = locationUpdater.getNewDelimiter(oldAddr); + } + if (newAddr && state.needToEmit()) { + // LLVM sometimes emits the same address more than once. We should + // probably investigate that. + if (newAddrInfo.count(newAddr)) { + continue; + } + newAddrs.push_back(newAddr); + newAddrInfo.emplace(newAddr, state); + auto& updatedState = newAddrInfo.at(newAddr); + // The only difference is the address TODO other stuff? + updatedState.addr = newAddr; + // Reset relevant state. + state.resetAfterLine(); + } + if (opcode.Opcode == 0 && + opcode.SubOpcode == llvm::dwarf::DW_LNE_end_sequence) { + sequenceId++; + // We assume the number of sequences can fit in 32 bits, and -1 is + // an invalid value. + assert(sequenceId != uint32_t(-1)); + state = LineState(table, sequenceId); + } + } + } + // Sort the new addresses (which may be substantially different from the + // original layout after optimization). + std::sort(newAddrs.begin(), newAddrs.end()); + // Emit a new line table. + { + std::vector newOpcodes; + for (size_t i = 0; i < newAddrs.size(); i++) { + LineState state = newAddrInfo.at(newAddrs[i]); + assert(state.needToEmit()); + LineState lastState(table, -1); + if (i != 0) { + lastState = newAddrInfo.at(newAddrs[i - 1]); + // If the last line is in another sequence, clear the old state, as + // there is nothing to diff to. + if (lastState.sequenceId != state.sequenceId) { + lastState = LineState(table, -1); + } + } + // This line ends a sequence if there is no next line after it, or if + // the next line is in a different sequence. + bool endSequence = + i + 1 == newAddrs.size() || + newAddrInfo.at(newAddrs[i + 1]).sequenceId != state.sequenceId; + state.emitDiff(lastState, newOpcodes, table, endSequence); + } + table.Opcodes.swap(newOpcodes); + } + } + // After updating the contents, run the emitter in order to update the + // lengths of each section. We will use that to update offsets into the + // debug_line section. + std::vector computedLengths; + llvm::DWARFYAML::ComputeDebugLine(data, computedLengths); + BinaryLocation oldLocation = 0, newLocation = 0; + for (size_t i = 0; i < data.DebugLines.size(); i++) { + auto& table = data.DebugLines[i]; + locationUpdater.debugLineMap[oldLocation] = newLocation; + oldLocation += table.Length.getLength() + AddressSize; + newLocation += computedLengths[i] + AddressSize; + table.Length.setLength(computedLengths[i]); + } +} + +// Iterate in parallel over a DwarfContext representation element and a +// YAML element, which parallel each other. +template +static void iterContextAndYAML(const T& contextList, U& yamlList, W func) { + auto yamlValue = yamlList.begin(); + for (const auto& contextValue : contextList) { + assert(yamlValue != yamlList.end()); + func(contextValue, *yamlValue); + yamlValue++; + } + assert(yamlValue == yamlList.end()); +} + +// Updates a YAML entry from a DWARF DIE. Also updates LocationUpdater +// associating each .debug_loc entry with the base address of its corresponding +// compilation unit. +static void updateDIE(const llvm::DWARFDebugInfoEntry& DIE, + llvm::DWARFYAML::Entry& yamlEntry, + const llvm::DWARFAbbreviationDeclaration* abbrevDecl, + LocationUpdater& locationUpdater, + size_t compileUnitIndex) { + auto tag = DIE.getTag(); + // Pairs of low/high_pc require some special handling, as the high + // may be an offset relative to the low. First, process everything but + // the high pcs, so we see the low pcs first. + BinaryLocation oldLowPC = 0, newLowPC = 0; + iterContextAndYAML( + abbrevDecl->attributes(), + yamlEntry.Values, + [&](const llvm::DWARFAbbreviationDeclaration::AttributeSpec& attrSpec, + llvm::DWARFYAML::FormValue& yamlValue) { + auto attr = attrSpec.Attr; + if (attr == llvm::dwarf::DW_AT_low_pc) { + // This is an address. + BinaryLocation oldValue = yamlValue.Value, newValue = 0; + if (tag == llvm::dwarf::DW_TAG_GNU_call_site || + tag == llvm::dwarf::DW_TAG_inlined_subroutine || + tag == llvm::dwarf::DW_TAG_lexical_block || + tag == llvm::dwarf::DW_TAG_label) { + newValue = locationUpdater.getNewStart(oldValue); + } else if (tag == llvm::dwarf::DW_TAG_compile_unit) { + newValue = locationUpdater.getNewFuncStart(oldValue); + // Per the DWARF spec, "The base address of a compile unit is + // defined as the value of the DW_AT_low_pc attribute, if present." + locationUpdater.compileUnitBases[compileUnitIndex] = + LocationUpdater::OldToNew{oldValue, newValue}; + } else if (tag == llvm::dwarf::DW_TAG_subprogram) { + newValue = locationUpdater.getNewFuncStart(oldValue); + } else { + Fatal() << "unknown tag with low_pc " + << llvm::dwarf::TagString(tag).str(); + } + oldLowPC = oldValue; + newLowPC = newValue; + yamlValue.Value = newValue; + } else if (attr == llvm::dwarf::DW_AT_stmt_list) { + // This is an offset into the debug line section. + yamlValue.Value = + locationUpdater.getNewDebugLineLocation(yamlValue.Value); + } else if (attr == llvm::dwarf::DW_AT_location && + attrSpec.Form == llvm::dwarf::DW_FORM_sec_offset) { + BinaryLocation locOffset = yamlValue.Value; + locationUpdater.locToUnitMap[locOffset] = compileUnitIndex; + } + }); + // Next, process the high_pcs. + // TODO: do this more efficiently, without a second traversal (but that's a + // little tricky given the special double-traversal we have). + iterContextAndYAML( + abbrevDecl->attributes(), + yamlEntry.Values, + [&](const llvm::DWARFAbbreviationDeclaration::AttributeSpec& attrSpec, + llvm::DWARFYAML::FormValue& yamlValue) { + auto attr = attrSpec.Attr; + if (attr != llvm::dwarf::DW_AT_high_pc) { + return; + } + BinaryLocation oldValue = yamlValue.Value, newValue = 0; + bool isRelative = attrSpec.Form == llvm::dwarf::DW_FORM_data4; + if (isRelative) { + oldValue += oldLowPC; + } + if (tag == llvm::dwarf::DW_TAG_GNU_call_site || + tag == llvm::dwarf::DW_TAG_inlined_subroutine || + tag == llvm::dwarf::DW_TAG_lexical_block || + tag == llvm::dwarf::DW_TAG_label) { + newValue = locationUpdater.getNewExprEnd(oldValue); + } else if (tag == llvm::dwarf::DW_TAG_compile_unit || + tag == llvm::dwarf::DW_TAG_subprogram) { + newValue = locationUpdater.getNewFuncEnd(oldValue); + } else { + Fatal() << "unknown tag with low_pc " + << llvm::dwarf::TagString(tag).str(); + } + if (isRelative) { + newValue -= newLowPC; + } + yamlValue.Value = newValue; + }); +} + +static void updateCompileUnits(const BinaryenDWARFInfo& info, + llvm::DWARFYAML::Data& yaml, + LocationUpdater& locationUpdater) { + // The context has the high-level information we need, and the YAML is where + // we write changes. First, iterate over the compile units. + size_t compileUnitIndex = 0; + iterContextAndYAML( + info.context->compile_units(), + yaml.CompileUnits, + [&](const std::unique_ptr& CU, + llvm::DWARFYAML::Unit& yamlUnit) { + // Process the DIEs in each compile unit. + iterContextAndYAML( + CU->dies(), + yamlUnit.Entries, + [&](const llvm::DWARFDebugInfoEntry& DIE, + llvm::DWARFYAML::Entry& yamlEntry) { + // Process the entries in each relevant DIE, looking for attributes to + // change. + auto abbrevDecl = DIE.getAbbreviationDeclarationPtr(); + if (abbrevDecl) { + // This is relevant; look for things to update. + updateDIE( + DIE, yamlEntry, abbrevDecl, locationUpdater, compileUnitIndex); + } + }); + compileUnitIndex++; + }); +} + +static void updateRanges(llvm::DWARFYAML::Data& yaml, + const LocationUpdater& locationUpdater) { + // In each range section, try to update the start and end. If we no longer + // have something to map them to, we must skip that part. + size_t skip = 0; + for (size_t i = 0; i < yaml.Ranges.size(); i++) { + auto& range = yaml.Ranges[i]; + BinaryLocation oldStart = range.Start, oldEnd = range.End, newStart = 0, + newEnd = 0; + // If this is an end marker (0, 0), or an invalid range (0, x) or (x, 0) + // then just emit it as it is - either to mark the end, or to mark an + // invalid entry. + if (oldStart == 0 || oldEnd == 0) { + newStart = oldStart; + newEnd = oldEnd; + } else { + // This was a valid entry; update it. + newStart = locationUpdater.getNewStart(oldStart); + newEnd = locationUpdater.getNewEnd(oldEnd); + if (newStart == 0 || newEnd == 0) { + // This part of the range no longer has a mapping, so we must skip it. + // Don't use (0, 0) as that would be an end marker; emit something + // invalid for the debugger to ignore. + newStart = 0; + newEnd = 1; + } + // TODO even if range start and end markers have been preserved, + // instructions in the middle may have moved around, making the range no + // longer contiguous. We should check that, and possibly split/merge + // the range. Or, we may need to have tracking in the IR for this. + } + auto& writtenRange = yaml.Ranges[i - skip]; + writtenRange.Start = newStart; + writtenRange.End = newEnd; + } +} + +// A location that is ignoreable, i.e., not a special value like 0 or -1 (which +// would indicate an end or a base in .debug_loc). +static const BinaryLocation IGNOREABLE_LOCATION = 1; + +static bool isNewBaseLoc(const llvm::DWARFYAML::Loc& loc) { + return loc.Start == BinaryLocation(-1); +} + +static bool isEndMarkerLoc(const llvm::DWARFYAML::Loc& loc) { + return loc.Start == 0 && loc.End == 0; +} + +// Update the .debug_loc section. +static void updateLoc(llvm::DWARFYAML::Data& yaml, + const LocationUpdater& locationUpdater) { + // Similar to ranges, try to update the start and end. Note that here we + // can't skip since the location description is a variable number of bytes, + // so we mark no longer valid addresses as empty. + bool atStart = true; + // We need to keep positions in the .debug_loc section identical to before + // (or else we'd need to update their positions too) and so we need to keep + // base entries around (a base entry is added to every entry after it in the + // list). However, we may change the base's value as after moving instructions + // around the old base may not be smaller than all the values relative to it. + BinaryLocation oldBase, newBase; + auto& locs = yaml.Locs; + for (size_t i = 0; i < locs.size(); i++) { + auto& loc = locs[i]; + if (atStart) { + std::tie(oldBase, newBase) = + locationUpdater.getCompileUnitBasesForLoc(loc.CompileUnitOffset); + atStart = false; + } + // By default we copy values over, unless we modify them below. + BinaryLocation newStart = loc.Start, newEnd = loc.End; + if (isNewBaseLoc(loc)) { + // This is a new base. + // Note that the base is not the address of an instruction, necessarily - + // it's just a number (seems like it could always be an instruction, but + // that's not what LLVM emits). + // We must look forward at everything relative to this base, so that we + // can emit a new proper base (as mentioned earlier, the original base may + // not be valid if instructions moved to a position before it - they must + // be positive offsets from it). + oldBase = newBase = newEnd; + BinaryLocation smallest = -1; + for (size_t j = i + 1; j < locs.size(); j++) { + auto& futureLoc = locs[j]; + if (isNewBaseLoc(futureLoc) || isEndMarkerLoc(futureLoc)) { + break; + } + auto updatedStart = + locationUpdater.getNewStart(futureLoc.Start + oldBase); + // If we found a valid mapping, this is a relevant value for us. If the + // optimizer removed it, it's a 0, and we can ignore it here - we will + // emit IGNOREABLE_LOCATION for it later anyhow. + if (updatedStart != 0) { + smallest = std::min(smallest, updatedStart); + } + } + // If we found no valid values that will be relativized here, just use 0 + // as the new (never-to-be-used) base, which is less confusing (otherwise + // the value looks like it means something). + if (smallest == BinaryLocation(-1)) { + smallest = 0; + } + newBase = newEnd = smallest; + } else if (isEndMarkerLoc(loc)) { + // This is an end marker, this list is done; reset the base. + atStart = true; + } else { + // This is a normal entry, try to find what it should be updated to. First + // de-relativize it to the base to get the absolute address, then look for + // a new address for it. + newStart = locationUpdater.getNewStart(loc.Start + oldBase); + newEnd = locationUpdater.getNewEnd(loc.End + oldBase); + if (newStart == 0 || newEnd == 0 || newStart > newEnd) { + // This part of the loc no longer has a mapping, or after the mapping + // it is no longer a proper span, so we must ignore it. + newStart = newEnd = IGNOREABLE_LOCATION; + } else { + // We picked a new base that ensures it is smaller than the values we + // will relativize to it. + assert(newStart >= newBase && newEnd >= newBase); + newStart -= newBase; + newEnd -= newBase; + if (newStart == 0 && newEnd == 0) { + // After mapping to the new positions, and after relativizing to the + // base, if we end up with (0, 0) then we must emit something else, as + // that would be interpreted as the end of a list. As it is an empty + // span, the actual value doesn't matter, it just has to be != 0. + // This can happen if the very first span in a compile unit is an + // empty span, in which case relative to the base of the compile unit + // we would have (0, 0). + newStart = newEnd = IGNOREABLE_LOCATION; + } + } + // The loc start and end markers have been preserved. However, TODO + // instructions in the middle may have moved around, making the loc no + // longer contiguous, we should check that, and possibly split/merge + // the loc. Or, we may need to have tracking in the IR for this. + } + loc.Start = newStart; + loc.End = newEnd; + // Note how the ".Location" field is unchanged. + } +} + +void writeDWARFSections(Module& wasm, const BinaryLocations& newLocations) { + BinaryenDWARFInfo info(wasm); + + // Convert to Data representation, which YAML can use to write. + llvm::DWARFYAML::Data data; + if (dwarf2yaml(*info.context, data)) { + Fatal() << "Failed to parse DWARF to YAML"; + } + + LocationUpdater locationUpdater(wasm, newLocations); + + updateDebugLines(data, locationUpdater); + + updateCompileUnits(info, data, locationUpdater); + + updateRanges(data, locationUpdater); + + updateLoc(data, locationUpdater); + + // Convert to binary sections. + auto newSections = + EmitDebugSections(data, false /* EmitFixups for debug_info */); + + // Update the custom sections in the wasm. + // TODO: efficiency + for (auto& section : wasm.userSections) { + if (Name(section.name).startsWith(".debug_")) { + auto llvmName = section.name.substr(1); + if (newSections.count(llvmName)) { + auto llvmData = newSections[llvmName]->getBuffer(); + section.data.resize(llvmData.size()); + std::copy(llvmData.begin(), llvmData.end(), section.data.data()); + } + } + } +} + +#else // BUILD_LLVM_DWARF + +void dumpDWARF(const Module& wasm) { + std::cerr << "warning: no DWARF dumping support present\n"; +} + +void writeDWARFSections(Module& wasm, const BinaryLocations& newLocations) { + std::cerr << "warning: no DWARF updating support present\n"; +} + +#endif // BUILD_LLVM_DWARF + +} // namespace Debug + +} // namespace wasm diff --git a/binaryen/src/wasm/wasm-emscripten.cpp b/binaryen/src/wasm/wasm-emscripten.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/wasm/wasm-emscripten.cpp @@ -0,0 +1,702 @@ +/* + * Copyright 2016 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "wasm-emscripten.h" + +#include + +#include "asm_v_wasm.h" +#include "asmjs/shared-constants.h" +#include "ir/import-utils.h" +#include "ir/literal-utils.h" +#include "ir/module-utils.h" +#include "ir/table-utils.h" +#include "shared-constants.h" +#include "support/debug.h" +#include "wasm-builder.h" +#include "wasm-traversal.h" +#include "wasm.h" + +#define DEBUG_TYPE "emscripten" + +namespace wasm { + +cashew::IString EM_ASM_PREFIX("emscripten_asm_const"); +cashew::IString EM_JS_PREFIX("__em_js__"); + +static Name STACK_INIT("stack$init"); +static Name POST_INSTANTIATE("__post_instantiate"); + +void addExportedFunction(Module& wasm, Function* function) { + wasm.addFunction(function); + auto export_ = new Export; + export_->name = export_->value = function->name; + export_->kind = ExternalKind::Function; + wasm.addExport(export_); +} + +// TODO(sbc): There should probably be a better way to do this. +bool isExported(Module& wasm, Name name) { + for (auto& ex : wasm.exports) { + if (ex->value == name) { + return true; + } + } + return false; +} + +Global* getStackPointerGlobal(Module& wasm) { + // Assumption: The stack pointer is either imported as __stack_pointer or + // its the first non-imported and non-exported global. + // TODO(sbc): Find a better way to discover the stack pointer. Perhaps the + // linker could export it by name? + for (auto& g : wasm.globals) { + if (g->imported()) { + if (g->base == STACK_POINTER) { + return g.get(); + } + } else if (!isExported(wasm, g->name)) { + return g.get(); + } + } + return nullptr; +} + +// For emscripten SIDE_MODULE we generate a single exported function called +// __post_instantiate which calls two functions: +// +// - __assign_got_enties +// - __wasm_call_ctors +// +// The former is function we generate here which calls imported g$XXX functions +// order to assign values to any globals imported from GOT.func or GOT.mem. +// These globals hold address of functions and globals respectively. +// +// The later is the constructor function generaed by lld which performs any +// fixups on the memory section and calls static constructors. +void EmscriptenGlueGenerator::generatePostInstantiateFunction() { + BYN_TRACE("generatePostInstantiateFunction\n"); + Builder builder(wasm); + Function* post_instantiate = builder.makeFunction( + POST_INSTANTIATE, std::vector{}, Type::none, {}); + wasm.addFunction(post_instantiate); + + if (Function* F = wasm.getFunctionOrNull(ASSIGN_GOT_ENTRIES)) { + // call __assign_got_enties from post_instantiate + Expression* call = builder.makeCall(F->name, {}, Type::none); + post_instantiate->body = builder.blockify(post_instantiate->body, call); + } + + // The names of standard imports/exports used by lld doesn't quite match that + // expected by emscripten. + // TODO(sbc): Unify these + if (auto* e = wasm.getExportOrNull(WASM_CALL_CTORS)) { + Expression* call = builder.makeCall(e->value, {}, Type::none); + post_instantiate->body = builder.blockify(post_instantiate->body, call); + wasm.removeExport(WASM_CALL_CTORS); + } + + auto* ex = new Export(); + ex->value = post_instantiate->name; + ex->name = POST_INSTANTIATE; + ex->kind = ExternalKind::Function; + wasm.addExport(ex); +} + +// lld can sometimes produce a build with an imported mutable __stack_pointer +// (i.e. when linking with -fpie). This method internalizes the +// __stack_pointer and initializes it from an immutable global instead. +// For -shared builds we instead call replaceStackPointerGlobal. +void EmscriptenGlueGenerator::internalizeStackPointerGlobal() { + Global* stackPointer = getStackPointerGlobal(wasm); + if (!stackPointer || !stackPointer->imported() || !stackPointer->mutable_) { + return; + } + + Name internalName = stackPointer->name; + Name externalName = internalName.c_str() + std::string("_import"); + + // Rename the imported global, and make it immutable + stackPointer->name = externalName; + stackPointer->mutable_ = false; + wasm.updateMaps(); + + // Create a new global with the old name that is not imported. + Builder builder(wasm); + auto* init = builder.makeGlobalGet(externalName, stackPointer->type); + auto* sp = builder.makeGlobal( + internalName, stackPointer->type, init, Builder::Mutable); + wasm.addGlobal(sp); +} + +const Address UNKNOWN_OFFSET(uint32_t(-1)); + +std::vector
getSegmentOffsets(Module& wasm) { + std::unordered_map passiveOffsets; + if (wasm.features.hasBulkMemory()) { + // Fetch passive segment offsets out of memory.init instructions + struct OffsetSearcher : PostWalker { + std::unordered_map& offsets; + OffsetSearcher(std::unordered_map& offsets) + : offsets(offsets) {} + void visitMemoryInit(MemoryInit* curr) { + auto* dest = curr->dest->dynCast(); + if (!dest) { + return; + } + auto it = offsets.find(curr->segment); + if (it != offsets.end()) { + Fatal() << "Cannot get offset of passive segment initialized " + "multiple times"; + } + offsets[curr->segment] = dest->value.geti32(); + } + } searcher(passiveOffsets); + searcher.walkModule(&wasm); + } + std::vector
segmentOffsets; + for (unsigned i = 0; i < wasm.memory.segments.size(); ++i) { + auto& segment = wasm.memory.segments[i]; + if (segment.isPassive) { + auto it = passiveOffsets.find(i); + if (it != passiveOffsets.end()) { + segmentOffsets.push_back(it->second); + } else { + // This was a non-constant offset (perhaps TLS) + segmentOffsets.push_back(UNKNOWN_OFFSET); + } + } else if (auto* addrConst = segment.offset->dynCast()) { + auto address = addrConst->value.geti32(); + segmentOffsets.push_back(address); + } else { + // TODO(sbc): Wasm shared libraries have data segments with non-const + // offset. + segmentOffsets.push_back(0); + } + } + return segmentOffsets; +} + +std::string escape(const char* input) { + std::string code = input; + // replace newlines quotes with escaped newlines + size_t curr = 0; + while ((curr = code.find("\\n", curr)) != std::string::npos) { + code = code.replace(curr, 2, "\\\\n"); + curr += 3; // skip this one + } + // replace double quotes with escaped single quotes + curr = 0; + while ((curr = code.find('"', curr)) != std::string::npos) { + if (curr == 0 || code[curr - 1] != '\\') { + code = code.replace(curr, + 1, + "\\" + "\""); + curr += 2; // skip this one + } else { // already escaped, escape the slash as well + code = code.replace(curr, + 1, + "\\" + "\\" + "\""); + curr += 3; // skip this one + } + } + return code; +} + +const char* stringAtAddr(Module& wasm, + std::vector
const& segmentOffsets, + Address address) { + for (unsigned i = 0; i < wasm.memory.segments.size(); ++i) { + Memory::Segment& segment = wasm.memory.segments[i]; + Address offset = segmentOffsets[i]; + if (offset != UNKNOWN_OFFSET && address >= offset && + address < offset + segment.data.size()) { + return &segment.data[address - offset]; + } + } + return nullptr; +} + +std::string codeForConstAddr(Module& wasm, + std::vector
const& segmentOffsets, + int32_t address) { + const char* str = stringAtAddr(wasm, segmentOffsets, address); + if (!str) { + // If we can't find the segment corresponding with the address, then we + // omitted the segment and the address points to an empty string. + return escape(""); + } + return escape(str); +} + +enum class Proxying { + None, + Sync, + Async, +}; + +std::string proxyingSuffix(Proxying proxy) { + switch (proxy) { + case Proxying::None: + return ""; + case Proxying::Sync: + return "sync_on_main_thread_"; + case Proxying::Async: + return "async_on_main_thread_"; + } + WASM_UNREACHABLE("invalid prozy type"); +} + +struct AsmConstWalker : public LinearExecutionWalker { + Module& wasm; + bool minimizeWasmChanges; + std::vector
segmentOffsets; // segment index => address offset + + struct AsmConst { + std::set sigs; + Address id; + std::string code; + Proxying proxy; + }; + + std::vector asmConsts; + std::set> allSigs; + // last sets in the current basic block, per index + std::map sets; + + AsmConstWalker(Module& _wasm, bool minimizeWasmChanges) + : wasm(_wasm), minimizeWasmChanges(minimizeWasmChanges), + segmentOffsets(getSegmentOffsets(wasm)) {} + + void noteNonLinear(Expression* curr); + + void visitLocalSet(LocalSet* curr); + void visitCall(Call* curr); + + void process(); + +private: + void createAsmConst(uint32_t id, std::string code, Signature sig, Name name); + Signature asmConstSig(Signature baseSig); + Name nameForImportWithSig(Signature sig, Proxying proxy); + void queueImport(Name importName, Signature baseSig); + void addImports(); + Proxying proxyType(Name name); + + std::vector> queuedImports; +}; + +void AsmConstWalker::noteNonLinear(Expression* curr) { + // End of this basic block; clear sets. + sets.clear(); +} + +void AsmConstWalker::visitLocalSet(LocalSet* curr) { sets[curr->index] = curr; } + +void AsmConstWalker::visitCall(Call* curr) { + auto* import = wasm.getFunction(curr->target); + // Find calls to emscripten_asm_const* functions whose first argument is + // is always a string constant. + if (!import->imported()) { + return; + } + auto importName = import->base; + if (!importName.hasSubstring(EM_ASM_PREFIX)) { + return; + } + + auto baseSig = wasm.getFunction(curr->target)->sig; + auto sig = asmConstSig(baseSig); + auto* arg = curr->operands[0]; + while (!arg->dynCast()) { + if (auto* get = arg->dynCast()) { + // The argument may be a local.get, in which case, the last set in this + // basic block has the value. + auto* set = sets[get->index]; + if (set) { + assert(set->index == get->index); + arg = set->value; + } else { + Fatal() << "local.get of unknown in arg0 of call to " << importName + << " (used by EM_ASM* macros) in function " + << getFunction()->name + << ".\nThis might be caused by aggressive compiler " + "transformations. Consider using EM_JS instead."; + } + continue; + } + + if (auto* setlocal = arg->dynCast()) { + // The argument may be a local.tee, in which case we take first child + // which is the value being copied into the local. + if (setlocal->isTee()) { + arg = setlocal->value; + continue; + } + } + + if (auto* bin = arg->dynCast()) { + if (bin->op == AddInt32) { + // In the dynamic linking case the address of the string constant + // is the result of adding its offset to __memory_base. + // In this case are only looking for the offset from __memory_base + // the RHS of the addition is just what we want. + arg = bin->right; + continue; + } + } + + Fatal() << "Unexpected arg0 type (" << getExpressionName(arg) + << ") in call to: " << importName; + } + + auto* value = arg->cast(); + int32_t address = value->value.geti32(); + auto code = codeForConstAddr(wasm, segmentOffsets, address); + createAsmConst(address, code, sig, importName); +} + +Proxying AsmConstWalker::proxyType(Name name) { + if (name.hasSubstring("_sync_on_main_thread")) { + return Proxying::Sync; + } else if (name.hasSubstring("_async_on_main_thread")) { + return Proxying::Async; + } + return Proxying::None; +} + +void AsmConstWalker::process() { + // Find and queue necessary imports + walkModule(&wasm); + // Add them after the walk, to avoid iterator invalidation on + // the list of functions. + addImports(); +} + +void AsmConstWalker::createAsmConst(uint32_t id, + std::string code, + Signature sig, + Name name) { + AsmConst asmConst; + asmConst.id = id; + asmConst.code = code; + asmConst.sigs.insert(sig); + asmConst.proxy = proxyType(name); + asmConsts.push_back(asmConst); +} + +Signature AsmConstWalker::asmConstSig(Signature baseSig) { + assert(baseSig.params.size() >= 1); + // Omit the signature of the "code" parameter, taken as a string, as the + // first argument + return Signature( + Type(std::vector(baseSig.params.begin() + 1, baseSig.params.end())), + baseSig.results); +} + +Name AsmConstWalker::nameForImportWithSig(Signature sig, Proxying proxy) { + std::string fixedTarget = EM_ASM_PREFIX.str + std::string("_") + + proxyingSuffix(proxy) + + getSig(sig.results, sig.params); + return Name(fixedTarget.c_str()); +} + +void AsmConstWalker::queueImport(Name importName, Signature baseSig) { + auto import = new Function; + import->name = import->base = importName; + import->module = ENV; + import->sig = baseSig; + queuedImports.push_back(std::unique_ptr(import)); +} + +void AsmConstWalker::addImports() { + for (auto& import : queuedImports) { + wasm.addFunction(import.release()); + } +} + +static AsmConstWalker fixEmAsmConstsAndReturnWalker(Module& wasm, + bool minimizeWasmChanges) { + AsmConstWalker walker(wasm, minimizeWasmChanges); + walker.process(); + return walker; +} + +struct EmJsWalker : public PostWalker { + Module& wasm; + std::vector
segmentOffsets; // segment index => address offset + + std::map codeByName; + + EmJsWalker(Module& _wasm) + : wasm(_wasm), segmentOffsets(getSegmentOffsets(wasm)) {} + + void visitExport(Export* curr) { + if (curr->kind != ExternalKind::Function) { + return; + } + if (!curr->name.startsWith(EM_JS_PREFIX.str)) { + return; + } + auto* func = wasm.getFunction(curr->value); + auto funcName = std::string(curr->name.stripPrefix(EM_JS_PREFIX.str)); + // An EM_JS has a single const in the body. Typically it is just returned, + // but in unoptimized code it might be stored to a local and loaded from + // there, and in relocatable code it might get added to __memory_base etc. + FindAll consts(func->body); + if (consts.list.size() != 1) { + Fatal() << "Unexpected generated __em_js__ function body: " << curr->name; + } + auto* addrConst = consts.list[0]; + int32_t address = addrConst->value.geti32(); + auto code = codeForConstAddr(wasm, segmentOffsets, address); + codeByName[funcName] = code; + } +}; + +EmJsWalker fixEmJsFuncsAndReturnWalker(Module& wasm) { + EmJsWalker walker(wasm); + walker.walkModule(&wasm); + + std::vector toRemove; + for (auto& func : wasm.functions) { + if (func->name.startsWith(EM_JS_PREFIX.str)) { + toRemove.push_back(func->name); + } + } + for (auto funcName : toRemove) { + wasm.removeFunction(funcName); + wasm.removeExport(funcName); + } + return walker; +} + +void printSignatures(std::ostream& o, const std::set& c) { + o << "["; + bool first = true; + for (auto& sig : c) { + if (first) { + first = false; + } else { + o << ","; + } + o << '"' << getSig(sig.results, sig.params) << '"'; + } + o << "]"; +} + +std::string EmscriptenGlueGenerator::generateEmscriptenMetadata( + Address staticBump, std::vector const& initializerFunctions) { + bool commaFirst; + auto nextElement = [&commaFirst]() { + if (commaFirst) { + commaFirst = false; + return "\n "; + } else { + return ",\n "; + } + }; + + std::stringstream meta; + meta << "{\n"; + + AsmConstWalker emAsmWalker = + fixEmAsmConstsAndReturnWalker(wasm, minimizeWasmChanges); + + // print + commaFirst = true; + if (!emAsmWalker.asmConsts.empty()) { + meta << " \"asmConsts\": {"; + for (auto& asmConst : emAsmWalker.asmConsts) { + meta << nextElement(); + meta << '"' << asmConst.id << "\": [\"" << asmConst.code << "\", "; + printSignatures(meta, asmConst.sigs); + meta << ", [\"" << proxyingSuffix(asmConst.proxy) << "\"]"; + + meta << "]"; + } + meta << "\n },\n"; + } + + EmJsWalker emJsWalker = fixEmJsFuncsAndReturnWalker(wasm); + if (!emJsWalker.codeByName.empty()) { + meta << " \"emJsFuncs\": {"; + commaFirst = true; + for (auto& pair : emJsWalker.codeByName) { + auto& name = pair.first; + auto& code = pair.second; + meta << nextElement(); + meta << '"' << name << "\": \"" << code << '"'; + } + meta << "\n },\n"; + } + + meta << " \"staticBump\": " << staticBump << ",\n"; + meta << " \"tableSize\": " << wasm.table.initial.addr << ",\n"; + + if (!initializerFunctions.empty()) { + meta << " \"initializers\": ["; + commaFirst = true; + for (const auto& func : initializerFunctions) { + meta << nextElement(); + meta << "\"" << func.c_str() << "\""; + } + meta << "\n ],\n"; + } + + // Avoid adding duplicate imports to `declares' or `invokeFuncs`. Even + // though we might import the same function multiple times (i.e. with + // different sigs) we only need to list is in the metadata once. + std::set declares; + std::set invokeFuncs; + + // We use the `base` rather than the `name` of the imports here and below + // becasue this is the externally visible name that the embedder (JS) will + // see. + meta << " \"declares\": ["; + commaFirst = true; + ModuleUtils::iterImportedFunctions(wasm, [&](Function* import) { + if (emJsWalker.codeByName.count(import->base.str) == 0 && + !import->base.startsWith("invoke_")) { + if (declares.insert(import->base.str).second) { + meta << nextElement() << '"' << import->base.str << '"'; + } + } + }); + meta << "\n ],\n"; + + meta << " \"externs\": ["; + commaFirst = true; + ModuleUtils::iterImportedGlobals(wasm, [&](Global* import) { + if (!(import->module == ENV && import->name == STACK_INIT)) { + meta << nextElement() << "\"_" << import->base.str << '"'; + } + }); + meta << "\n ],\n"; + + if (!wasm.exports.empty()) { + meta << " \"exports\": ["; + commaFirst = true; + for (const auto& ex : wasm.exports) { + if (ex->kind == ExternalKind::Function) { + meta << nextElement() << '"' << ex->name.str << '"'; + } + } + meta << "\n ],\n"; + + meta << " \"namedGlobals\": {"; + commaFirst = true; + for (const auto& ex : wasm.exports) { + if (ex->kind == ExternalKind::Global) { + const Global* g = wasm.getGlobal(ex->value); + assert(g->type == Type::i32); + Const* init = g->init->cast(); + uint32_t addr = init->value.geti32(); + meta << nextElement() << '"' << ex->name.str << "\" : \"" << addr + << '"'; + } + } + meta << "\n },\n"; + } + + meta << " \"invokeFuncs\": ["; + commaFirst = true; + ModuleUtils::iterImportedFunctions(wasm, [&](Function* import) { + if (import->module == ENV && import->base.startsWith("invoke_")) { + if (invokeFuncs.insert(import->base.str).second) { + meta << nextElement() << '"' << import->base.str << '"'; + } + } + }); + meta << "\n ],\n"; + + // In normal mode we attempt to determine if main takes argumnts or not + // In standalone mode we export _start instead and rely on the presence + // of the __wasi_args_get and __wasi_args_sizes_get syscalls allow us to + // DCE to the argument handling JS code instead. + if (!standalone) { + auto mainReadsParams = false; + auto* exp = wasm.getExportOrNull("main"); + if (!exp) { + exp = wasm.getExportOrNull("__main_argc_argv"); + } + if (exp) { + if (exp->kind == ExternalKind::Function) { + auto* main = wasm.getFunction(exp->value); + mainReadsParams = true; + // If main does not read its parameters, it will just be a stub that + // calls __original_main (which has no parameters). + if (auto* call = main->body->dynCast()) { + if (call->operands.empty()) { + mainReadsParams = false; + } + } + } + } + meta << " \"mainReadsParams\": " << int(mainReadsParams) << ",\n"; + } + + meta << " \"features\": ["; + commaFirst = true; + wasm.features.iterFeatures([&](FeatureSet::Feature f) { + meta << nextElement() << "\"--enable-" << FeatureSet::toString(f) << '"'; + }); + meta << "\n ]\n"; + + meta << "}\n"; + + return meta.str(); +} + +void EmscriptenGlueGenerator::separateDataSegments(Output* outfile, + Address base) { + size_t lastEnd = 0; + for (Memory::Segment& seg : wasm.memory.segments) { + if (seg.isPassive) { + Fatal() << "separating passive segments not implemented"; + } + if (!seg.offset->is()) { + Fatal() << "separating relocatable segments not implemented"; + } + size_t offset = seg.offset->cast()->value.geti32(); + offset -= base; + size_t fill = offset - lastEnd; + if (fill > 0) { + std::vector buf(fill); + outfile->write(buf.data(), fill); + } + outfile->write(seg.data.data(), seg.data.size()); + lastEnd = offset + seg.data.size(); + } + wasm.memory.segments.clear(); +} + +void EmscriptenGlueGenerator::renameMainArgcArgv() { + // If an export call ed __main_argc_argv exists rename it to main + Export* ex = wasm.getExportOrNull("__main_argc_argv"); + if (!ex) { + BYN_TRACE("renameMain: __main_argc_argv not found\n"); + return; + } + ex->name = "main"; + wasm.updateMaps(); + ModuleUtils::renameFunction(wasm, "__main_argc_argv", "main"); +} + +} // namespace wasm diff --git a/binaryen/src/wasm/wasm-interpreter.cpp b/binaryen/src/wasm/wasm-interpreter.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/wasm/wasm-interpreter.cpp @@ -0,0 +1,22 @@ +#include "wasm-interpreter.h" + +namespace wasm { + +#ifdef WASM_INTERPRETER_DEBUG +int Indenter::indentLevel = 0; + +Indenter::Indenter(const char* entry) : entryName(entry) { ++indentLevel; } +Indenter::~Indenter() { + print(); + std::cout << "exit " << entryName << '\n'; + --indentLevel; +} +void Indenter::print() { + std::cout << indentLevel << ':'; + for (int i = 0; i <= indentLevel; ++i) { + std::cout << ' '; + } +} +#endif // WASM_INTERPRETER_DEBUG + +} // namespace wasm diff --git a/binaryen/src/wasm/wasm-io.cpp b/binaryen/src/wasm/wasm-io.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/wasm/wasm-io.cpp @@ -0,0 +1,176 @@ +/* + * Copyright 2017 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// +// Abstracts reading and writing, supporting both text and binary +// depending on the suffix. +// +// When the suffix is unclear, writing defaults to text (this +// allows odd suffixes, which we use in the test suite), while +// reading will check the magic number and default to text if not +// binary. +// + +#include "wasm-io.h" +#include "support/debug.h" +#include "wasm-binary.h" +#include "wasm-s-parser.h" + +namespace wasm { + +#define DEBUG_TYPE "writer" + +static void readTextData(std::string& input, Module& wasm, IRProfile profile) { + SExpressionParser parser(const_cast(input.c_str())); + Element& root = *parser.root; + SExpressionWasmBuilder builder(wasm, *root[0], profile); +} + +void ModuleReader::readText(std::string filename, Module& wasm) { + BYN_TRACE("reading text from " << filename << "\n"); + auto input(read_file(filename, Flags::Text)); + readTextData(input, wasm, profile); +} + +void ModuleReader::readBinaryData(std::vector& input, + Module& wasm, + std::string sourceMapFilename) { + std::unique_ptr sourceMapStream; + WasmBinaryBuilder parser(wasm, input); + parser.setDWARF(DWARF); + if (sourceMapFilename.size()) { + sourceMapStream = make_unique(); + sourceMapStream->open(sourceMapFilename); + parser.setDebugLocations(sourceMapStream.get()); + } + parser.read(); + if (sourceMapStream) { + sourceMapStream->close(); + } +} + +void ModuleReader::readBinary(std::string filename, + Module& wasm, + std::string sourceMapFilename) { + BYN_TRACE("reading binary from " << filename << "\n"); + auto input(read_file>(filename, Flags::Binary)); + readBinaryData(input, wasm, sourceMapFilename); +} + +bool ModuleReader::isBinaryFile(std::string filename) { + std::ifstream infile; + std::ios_base::openmode flags = std::ifstream::in | std::ifstream::binary; + infile.open(filename, flags); + char buffer[4] = {1, 2, 3, 4}; + infile.read(buffer, 4); + infile.close(); + return buffer[0] == '\0' && buffer[1] == 'a' && buffer[2] == 's' && + buffer[3] == 'm'; +} + +void ModuleReader::read(std::string filename, + Module& wasm, + std::string sourceMapFilename) { + // empty filename means read from stdin + if (!filename.size()) { + readStdin(wasm, sourceMapFilename); + return; + } + if (isBinaryFile(filename)) { + readBinary(filename, wasm, sourceMapFilename); + } else { + // default to text + if (sourceMapFilename.size()) { + std::cerr << "Binaryen ModuleReader::read() - source map filename " + "provided, but file appears to not be binary\n"; + } + readText(filename, wasm); + } +} + +// TODO: reading into a vector then copying into a string is unnecessarily +// inefficient. It would be better to read just once into a stringstream. +void ModuleReader::readStdin(Module& wasm, std::string sourceMapFilename) { + std::vector input = read_stdin(); + if (input.size() >= 4 && input[0] == '\0' && input[1] == 'a' && + input[2] == 's' && input[3] == 'm') { + readBinaryData(input, wasm, sourceMapFilename); + } else { + std::ostringstream s; + s.write(input.data(), input.size()); + s << '\0'; + std::string input_str = s.str(); + readTextData(input_str, wasm, profile); + } +} + +#undef DEBUG_TYPE +#define DEBUG_TYPE "writer" + +void ModuleWriter::writeText(Module& wasm, Output& output) { + WasmPrinter::printModule(&wasm, output.getStream()); +} + +void ModuleWriter::writeText(Module& wasm, std::string filename) { + BYN_TRACE("writing text to " << filename << "\n"); + Output output(filename, Flags::Text); + writeText(wasm, output); +} + +void ModuleWriter::writeBinary(Module& wasm, Output& output) { + BufferWithRandomAccess buffer; + WasmBinaryWriter writer(&wasm, buffer); + // if debug info is used, then we want to emit the names section + writer.setNamesSection(debugInfo); + std::unique_ptr sourceMapStream; + if (sourceMapFilename.size()) { + sourceMapStream = make_unique(); + sourceMapStream->open(sourceMapFilename); + writer.setSourceMap(sourceMapStream.get(), sourceMapUrl); + } + if (symbolMap.size() > 0) { + writer.setSymbolMap(symbolMap); + } + writer.write(); + buffer.writeTo(output); + if (sourceMapStream) { + sourceMapStream->close(); + } +} + +void ModuleWriter::writeBinary(Module& wasm, std::string filename) { + BYN_TRACE("writing binary to " << filename << "\n"); + Output output(filename, Flags::Binary); + writeBinary(wasm, output); +} + +void ModuleWriter::write(Module& wasm, Output& output) { + if (binary) { + writeBinary(wasm, output); + } else { + writeText(wasm, output); + } +} + +void ModuleWriter::write(Module& wasm, std::string filename) { + if (binary && filename.size() > 0) { + writeBinary(wasm, filename); + } else { + writeText(wasm, filename); + } +} + +} // namespace wasm diff --git a/binaryen/src/wasm/wasm-s-parser.cpp b/binaryen/src/wasm/wasm-s-parser.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/wasm/wasm-s-parser.cpp @@ -0,0 +1,2778 @@ +/* + * Copyright 2015 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "wasm-s-parser.h" + +#include +#include +#include + +#include "asm_v_wasm.h" +#include "asmjs/shared-constants.h" +#include "ir/branch-utils.h" +#include "shared-constants.h" +#include "wasm-binary.h" + +#define abort_on(str) \ + { throw ParseException(std::string("abort_on ") + str); } +#define element_assert(condition) \ + assert((condition) ? true : (std::cerr << "on: " << *this << '\n' && 0)); + +using cashew::IString; + +namespace { +int unhex(char c) { + if (c >= '0' && c <= '9') { + return c - '0'; + } + if (c >= 'a' && c <= 'f') { + return c - 'a' + 10; + } + if (c >= 'A' && c <= 'F') { + return c - 'A' + 10; + } + throw wasm::ParseException("invalid hexadecimal"); +} +} // namespace + +namespace wasm { + +static Address getAddress(const Element* s) { return atoll(s->c_str()); } + +static void +checkAddress(Address a, const char* errorText, const Element* errorElem) { + if (a > std::numeric_limits::max()) { + throw ParseException(errorText, errorElem->line, errorElem->col); + } +} + +static bool elementStartsWith(Element& s, IString str) { + return s.isList() && s.size() > 0 && s[0]->isStr() && s[0]->str() == str; +} + +Element::List& Element::list() { + if (!isList()) { + throw ParseException("expected list", line, col); + } + return list_; +} + +Element* Element::operator[](unsigned i) { + if (!isList()) { + throw ParseException("expected list", line, col); + } + if (i >= list().size()) { + throw ParseException("expected more elements in list", line, col); + } + return list()[i]; +} + +IString Element::str() const { + if (!isStr()) { + throw ParseException("expected string", line, col); + } + return str_; +} + +const char* Element::c_str() const { + if (!isStr()) { + throw ParseException("expected string", line, col); + } + return str_.str; +} + +Element* Element::setString(IString str__, bool dollared__, bool quoted__) { + isList_ = false; + str_ = str__; + dollared_ = dollared__; + quoted_ = quoted__; + return this; +} + +Element* +Element::setMetadata(size_t line_, size_t col_, SourceLocation* startLoc_) { + line = line_; + col = col_; + startLoc = startLoc_; + return this; +} + +std::ostream& operator<<(std::ostream& o, Element& e) { + if (e.isList_) { + o << '('; + for (auto item : e.list_) { + o << ' ' << *item; + } + o << " )"; + } else { + o << e.str_.str; + } + return o; +} + +void Element::dump() { + std::cout << "dumping " << this << " : " << *this << ".\n"; +} + +SExpressionParser::SExpressionParser(char* input) : input(input) { + root = nullptr; + line = 1; + lineStart = input; + while (!root) { // keep parsing until we pass an initial comment + root = parse(); + } +} + +Element* SExpressionParser::parse() { + std::vector stack; + std::vector stackLocs; + Element* curr = allocator.alloc(); + while (1) { + skipWhitespace(); + if (input[0] == 0) { + break; + } + if (input[0] == '(') { + input++; + stack.push_back(curr); + curr = allocator.alloc()->setMetadata( + line, input - lineStart - 1, loc); + stackLocs.push_back(loc); + assert(stack.size() == stackLocs.size()); + } else if (input[0] == ')') { + input++; + curr->endLoc = loc; + auto last = curr; + if (stack.empty()) { + throw ParseException("s-expr stack empty"); + } + curr = stack.back(); + assert(stack.size() == stackLocs.size()); + stack.pop_back(); + loc = stackLocs.back(); + stackLocs.pop_back(); + curr->list().push_back(last); + } else { + curr->list().push_back(parseString()); + } + } + if (stack.size() != 0) { + throw ParseException("stack is not empty", curr->line, curr->col); + } + return curr; +} + +void SExpressionParser::parseDebugLocation() { + // Extracting debug location (if valid) + char* debugLoc = input + 3; // skipping ";;@" + while (debugLoc[0] && debugLoc[0] == ' ') { + debugLoc++; + } + char* debugLocEnd = debugLoc; + while (debugLocEnd[0] && debugLocEnd[0] != '\n') { + debugLocEnd++; + } + char* pos = debugLoc; + while (pos < debugLocEnd && pos[0] != ':') { + pos++; + } + if (pos >= debugLocEnd) { + return; // no line number + } + std::string name(debugLoc, pos); + char* lineStart = ++pos; + while (pos < debugLocEnd && pos[0] != ':') { + pos++; + } + std::string lineStr(lineStart, pos); + if (pos >= debugLocEnd) { + return; // no column number + } + std::string colStr(++pos, debugLocEnd); + void* buf = + allocator.allocSpace(sizeof(SourceLocation), alignof(SourceLocation)); + loc = new (buf) SourceLocation( + IString(name.c_str(), false), atoi(lineStr.c_str()), atoi(colStr.c_str())); +} + +void SExpressionParser::skipWhitespace() { + while (1) { + while (isspace(input[0])) { + if (input[0] == '\n') { + line++; + lineStart = input + 1; + } + input++; + } + if (input[0] == ';' && input[1] == ';') { + if (input[2] == '@') { + parseDebugLocation(); + } + while (input[0] && input[0] != '\n') { + input++; + } + line++; + if (!input[0]) { + return; + } + lineStart = ++input; + } else if (input[0] == '(' && input[1] == ';') { + // Skip nested block comments. + input += 2; + int depth = 1; + while (1) { + if (!input[0]) { + return; + } + if (input[0] == '(' && input[1] == ';') { + input += 2; + depth++; + } else if (input[0] == ';' && input[1] == ')') { + input += 2; + --depth; + if (depth == 0) { + break; + } + } else if (input[0] == '\n') { + line++; + lineStart = input; + input++; + } else { + input++; + } + } + } else { + return; + } + } +} + +Element* SExpressionParser::parseString() { + bool dollared = false; + if (input[0] == '$') { + input++; + dollared = true; + } + char* start = input; + if (input[0] == '"') { + // parse escaping \", but leave code escaped - we'll handle escaping in + // memory segments specifically + input++; + std::string str; + while (1) { + if (input[0] == 0) { + throw ParseException("unterminated string", line, start - lineStart); + } + if (input[0] == '"') { + break; + } + if (input[0] == '\\') { + str += input[0]; + if (input[1] == 0) { + throw ParseException( + "unterminated string escape", line, start - lineStart); + } + str += input[1]; + input += 2; + continue; + } + str += input[0]; + input++; + } + input++; + return allocator.alloc() + ->setString(IString(str.c_str(), false), dollared, true) + ->setMetadata(line, start - lineStart, loc); + } + while (input[0] && !isspace(input[0]) && input[0] != ')' && input[0] != '(' && + input[0] != ';') { + input++; + } + if (start == input) { + throw ParseException("expected string", line, input - lineStart); + } + char temp = input[0]; + input[0] = 0; + auto ret = allocator.alloc() + ->setString(IString(start, false), dollared, false) + ->setMetadata(line, start - lineStart, loc); + input[0] = temp; + return ret; +} + +SExpressionWasmBuilder::SExpressionWasmBuilder(Module& wasm, + Element& module, + IRProfile profile) + : wasm(wasm), allocator(wasm.allocator), profile(profile) { + if (module.size() == 0) { + throw ParseException("empty toplevel, expected module"); + } + if (module[0]->str() != MODULE) { + throw ParseException("toplevel does not start with module"); + } + if (module.size() == 1) { + return; + } + Index i = 1; + if (module[i]->dollared()) { + wasm.name = module[i]->str(); + i++; + } + if (i < module.size() && module[i]->isStr()) { + // these s-expressions contain a binary module, actually + std::vector data; + while (i < module.size()) { + auto str = module[i++]->c_str(); + if (auto size = strlen(str)) { + stringToBinary(str, size, data); + } + } + WasmBinaryBuilder binaryBuilder(wasm, data); + binaryBuilder.read(); + return; + } + Index implementedFunctions = 0; + functionCounter = 0; + for (unsigned j = i; j < module.size(); j++) { + auto& s = *module[j]; + preParseFunctionType(s); + preParseImports(s); + if (elementStartsWith(s, FUNC) && !isImport(s)) { + implementedFunctions++; + } + } + // we go through the functions again, now parsing them, and the counter begins + // from where imports ended + functionCounter -= implementedFunctions; + for (unsigned j = i; j < module.size(); j++) { + parseModuleElement(*module[j]); + } +} + +bool SExpressionWasmBuilder::isImport(Element& curr) { + for (Index i = 0; i < curr.size(); i++) { + auto& x = *curr[i]; + if (elementStartsWith(x, IMPORT)) { + return true; + } + } + return false; +} + +void SExpressionWasmBuilder::preParseImports(Element& curr) { + IString id = curr[0]->str(); + if (id == IMPORT) { + parseImport(curr); + } + if (isImport(curr)) { + if (id == FUNC) { + parseFunction(curr, true /* preParseImport */); + } else if (id == GLOBAL) { + parseGlobal(curr, true /* preParseImport */); + } else if (id == TABLE) { + parseTable(curr, true /* preParseImport */); + } else if (id == MEMORY) { + parseMemory(curr, true /* preParseImport */); + } else if (id == EVENT) { + parseEvent(curr, true /* preParseImport */); + } else { + throw ParseException( + "fancy import we don't support yet", curr.line, curr.col); + } + } +} + +void SExpressionWasmBuilder::parseModuleElement(Element& curr) { + if (isImport(curr)) { + return; // already done + } + IString id = curr[0]->str(); + if (id == START) { + return parseStart(curr); + } + if (id == FUNC) { + return parseFunction(curr); + } + if (id == MEMORY) { + return parseMemory(curr); + } + if (id == DATA) { + return parseData(curr); + } + if (id == EXPORT) { + return parseExport(curr); + } + if (id == IMPORT) { + return; // already done + } + if (id == GLOBAL) { + return parseGlobal(curr); + } + if (id == TABLE) { + return parseTable(curr); + } + if (id == ELEM) { + return parseElem(curr); + } + if (id == TYPE) { + return; // already done + } + if (id == EVENT) { + return parseEvent(curr); + } + std::cerr << "bad module element " << id.str << '\n'; + throw ParseException("unknown module element", curr.line, curr.col); +} + +Name SExpressionWasmBuilder::getFunctionName(Element& s) { + if (s.dollared()) { + return s.str(); + } else { + // index + size_t offset = atoi(s.str().c_str()); + if (offset >= functionNames.size()) { + throw ParseException( + "unknown function in getFunctionName", s.line, s.col); + } + return functionNames[offset]; + } +} + +Signature SExpressionWasmBuilder::getFunctionSignature(Element& s) { + if (s.dollared()) { + auto it = signatureIndices.find(s.str().str); + if (it == signatureIndices.end()) { + throw ParseException( + "unknown function type in getFunctionSignature", s.line, s.col); + } + return signatures[it->second]; + } else { + // index + size_t offset = atoi(s.str().c_str()); + if (offset >= signatures.size()) { + throw ParseException( + "unknown function type in getFunctionSignature", s.line, s.col); + } + return signatures[offset]; + } +} + +Name SExpressionWasmBuilder::getGlobalName(Element& s) { + if (s.dollared()) { + return s.str(); + } else { + // index + size_t offset = atoi(s.str().c_str()); + if (offset >= globalNames.size()) { + throw ParseException("unknown global in getGlobalName", s.line, s.col); + } + return globalNames[offset]; + } +} + +Name SExpressionWasmBuilder::getEventName(Element& s) { + if (s.dollared()) { + return s.str(); + } else { + // index + size_t offset = atoi(s.str().c_str()); + if (offset >= eventNames.size()) { + throw ParseException("unknown event in getEventName", s.line, s.col); + } + return eventNames[offset]; + } +} + +// Parse various forms of (param ...) or (local ...) element. This ignores all +// parameter or local names when specified. +std::vector SExpressionWasmBuilder::parseParamOrLocal(Element& s) { + size_t fakeIndex = 0; + std::vector namedParams = parseParamOrLocal(s, fakeIndex); + std::vector params; + for (auto& p : namedParams) { + params.push_back(p.type); + } + return params; +} + +// Parses various forms of (param ...) or (local ...) element: +// (param $name type) (e.g. (param $a i32)) +// (param type+) (e.g. (param i32 f64)) +// (local $name type) (e.g. (local $a i32)) +// (local type+) (e.g. (local i32 f64)) +// If the name is unspecified, it will create one using localIndex. +std::vector +SExpressionWasmBuilder::parseParamOrLocal(Element& s, size_t& localIndex) { + assert(elementStartsWith(s, PARAM) || elementStartsWith(s, LOCAL)); + std::vector namedParams; + if (s.size() == 1) { // (param) or (local) + return namedParams; + } + + for (size_t i = 1; i < s.size(); i++) { + IString name; + if (s[i]->dollared()) { + if (i != 1) { + throw ParseException("invalid wasm type", s[i]->line, s[i]->col); + } + if (i + 1 >= s.size()) { + throw ParseException("invalid param entry", s.line, s.col); + } + name = s[i]->str(); + i++; + } else { + name = Name::fromInt(localIndex); + } + localIndex++; + Type type; + if (s[i]->isStr()) { + type = stringToType(s[i]->str()); + } else { + if (elementStartsWith(s, PARAM)) { + throw ParseException( + "params may not have tuple types", s[i]->line, s[i]->col); + } + type = elementToType(*s[i]); + } + namedParams.emplace_back(name, type); + } + return namedParams; +} + +// Parses (result type) element. (e.g. (result i32)) +std::vector SExpressionWasmBuilder::parseResults(Element& s) { + assert(elementStartsWith(s, RESULT)); + std::vector types; + for (size_t i = 1; i < s.size(); i++) { + types.push_back(stringToType(s[i]->str())); + } + return types; +} + +// Parses an element that references an entry in the type section. The element +// should be in the form of (type name) or (type index). +// (e.g. (type $a), (type 0)) +Signature SExpressionWasmBuilder::parseTypeRef(Element& s) { + assert(elementStartsWith(s, TYPE)); + if (s.size() != 2) { + throw ParseException("invalid type reference", s.line, s.col); + } + return getFunctionSignature(*s[1]); +} + +// Prases typeuse, a reference to a type definition. It is in the form of either +// (type index) or (type name), possibly augmented by inlined (param) and +// (result) nodes. (type) node can be omitted as well. Outputs are returned by +// parameter references. +// typeuse ::= (type index|name)+ | +// (type index|name)+ (param ..)* (result ..)* | +// (param ..)* (result ..)* +size_t +SExpressionWasmBuilder::parseTypeUse(Element& s, + size_t startPos, + Signature& functionSignature, + std::vector& namedParams) { + std::vector params, results; + size_t i = startPos; + + bool typeExists = false, paramsOrResultsExist = false; + if (i < s.size() && elementStartsWith(*s[i], TYPE)) { + typeExists = true; + functionSignature = parseTypeRef(*s[i++]); + } + + size_t paramPos = i; + size_t localIndex = 0; + + while (i < s.size() && elementStartsWith(*s[i], PARAM)) { + paramsOrResultsExist = true; + auto newParams = parseParamOrLocal(*s[i++], localIndex); + namedParams.insert(namedParams.end(), newParams.begin(), newParams.end()); + for (auto p : newParams) { + params.push_back(p.type); + } + } + + while (i < s.size() && elementStartsWith(*s[i], RESULT)) { + paramsOrResultsExist = true; + auto newResults = parseResults(*s[i++]); + results.insert(results.end(), newResults.begin(), newResults.end()); + } + + auto inlineSig = Signature(Type(params), Type(results)); + + // If none of type/param/result exists, this is equivalent to a type that does + // not have parameters and returns nothing. + if (!typeExists && !paramsOrResultsExist) { + paramsOrResultsExist = true; + } + + if (!typeExists) { + functionSignature = inlineSig; + } else if (paramsOrResultsExist) { + // verify that (type) and (params)/(result) match + if (inlineSig != functionSignature) { + throw ParseException("type and param/result don't match", + s[paramPos]->line, + s[paramPos]->col); + } + } + + // Add implicitly defined type to global list so it has an index + if (std::find(signatures.begin(), signatures.end(), functionSignature) == + signatures.end()) { + signatures.push_back(functionSignature); + } + + // If only (type) is specified, populate `namedParams` + if (!paramsOrResultsExist) { + size_t index = 0; + for (const auto& param : functionSignature.params) { + namedParams.emplace_back(Name::fromInt(index++), param); + } + } + + return i; +} + +// Parses a typeuse. Use this when only FunctionType* is needed. +size_t SExpressionWasmBuilder::parseTypeUse(Element& s, + size_t startPos, + Signature& functionSignature) { + std::vector params; + return parseTypeUse(s, startPos, functionSignature, params); +} + +void SExpressionWasmBuilder::preParseFunctionType(Element& s) { + IString id = s[0]->str(); + if (id == TYPE) { + return parseType(s); + } + if (id != FUNC) { + return; + } + size_t i = 1; + Name name, exportName; + i = parseFunctionNames(s, name, exportName); + if (!name.is()) { + // unnamed, use an index + name = Name::fromInt(functionCounter); + } + functionNames.push_back(name); + functionCounter++; + Signature sig; + parseTypeUse(s, i, sig); + functionTypes[name] = sig.results; +} + +size_t SExpressionWasmBuilder::parseFunctionNames(Element& s, + Name& name, + Name& exportName) { + size_t i = 1; + while (i < s.size() && i < 3 && s[i]->isStr()) { + if (s[i]->quoted()) { + // an export name + exportName = s[i]->str(); + i++; + } else if (s[i]->dollared()) { + name = s[i]->str(); + i++; + } else { + break; + } + } + if (i < s.size() && s[i]->isList()) { + auto& inner = *s[i]; + if (elementStartsWith(inner, EXPORT)) { + exportName = inner[1]->str(); + i++; + } + } +#if 0 + if (exportName.is() && !name.is()) { + name = exportName; // useful for debugging + } +#endif + return i; +} + +void SExpressionWasmBuilder::parseFunction(Element& s, bool preParseImport) { + brokeToAutoBlock = false; + + Name name, exportName; + size_t i = parseFunctionNames(s, name, exportName); + if (!preParseImport) { + if (!name.is()) { + // unnamed, use an index + name = Name::fromInt(functionCounter); + } + functionCounter++; + } else { + // just preparsing, functionCounter was incremented by preParseFunctionType + if (!name.is()) { + // unnamed, use an index + name = functionNames[functionCounter - 1]; + } + } + if (exportName.is()) { + auto ex = make_unique(); + ex->name = exportName; + ex->value = name; + ex->kind = ExternalKind::Function; + if (wasm.getExportOrNull(ex->name)) { + throw ParseException("duplicate export", s.line, s.col); + } + wasm.addExport(ex.release()); + } + + // parse import + Name importModule, importBase; + if (i < s.size() && elementStartsWith(*s[i], IMPORT)) { + Element& curr = *s[i]; + importModule = curr[1]->str(); + importBase = curr[2]->str(); + i++; + } + + // parse typeuse: type/param/result + Signature sig; + std::vector params; + i = parseTypeUse(s, i, sig, params); + + // when (import) is inside a (func) element, this is not a function definition + // but an import. + if (importModule.is()) { + if (!importBase.size()) { + throw ParseException("module but no base for import", s.line, s.col); + } + if (!preParseImport) { + throw ParseException("!preParseImport in func", s.line, s.col); + } + auto im = make_unique(); + im->name = name; + im->module = importModule; + im->base = importBase; + im->sig = sig; + functionTypes[name] = sig.results; + if (wasm.getFunctionOrNull(im->name)) { + throw ParseException("duplicate import", s.line, s.col); + } + wasm.addFunction(im.release()); + if (currFunction) { + throw ParseException("import module inside function dec", s.line, s.col); + } + nameMapper.clear(); + return; + } + // at this point this not an import but a real function definition. + if (preParseImport) { + throw ParseException("preParseImport in func", s.line, s.col); + } + + size_t localIndex = params.size(); // local index for params and locals + + // parse locals + std::vector vars; + while (i < s.size() && elementStartsWith(*s[i], LOCAL)) { + auto newVars = parseParamOrLocal(*s[i++], localIndex); + vars.insert(vars.end(), newVars.begin(), newVars.end()); + } + + // make a new function + currFunction = std::unique_ptr(Builder(wasm).makeFunction( + name, std::move(params), sig.results, std::move(vars))); + currFunction->profile = profile; + + // parse body + Block* autoBlock = nullptr; // may need to add a block for the very top level + auto ensureAutoBlock = [&]() { + if (!autoBlock) { + autoBlock = allocator.alloc(); + autoBlock->list.push_back(currFunction->body); + currFunction->body = autoBlock; + } + }; + while (i < s.size()) { + Expression* ex = parseExpression(*s[i++]); + if (!currFunction->body) { + currFunction->body = ex; + } else { + ensureAutoBlock(); + autoBlock->list.push_back(ex); + } + } + + if (brokeToAutoBlock) { + ensureAutoBlock(); + autoBlock->name = FAKE_RETURN; + } + if (autoBlock) { + autoBlock->finalize(sig.results); + } + if (!currFunction->body) { + currFunction->body = allocator.alloc(); + } + if (s.startLoc) { + currFunction->prologLocation.insert(getDebugLocation(*s.startLoc)); + } + if (s.endLoc) { + currFunction->epilogLocation.insert(getDebugLocation(*s.endLoc)); + } + if (wasm.getFunctionOrNull(currFunction->name)) { + throw ParseException("duplicate function", s.line, s.col); + } + wasm.addFunction(currFunction.release()); + nameMapper.clear(); +} + +Type SExpressionWasmBuilder::stringToType(const char* str, + bool allowError, + bool prefix) { + if (str[0] == 'i') { + if (str[1] == '3' && str[2] == '2' && (prefix || str[3] == 0)) { + return Type::i32; + } + if (str[1] == '6' && str[2] == '4' && (prefix || str[3] == 0)) { + return Type::i64; + } + } + if (str[0] == 'f') { + if (str[1] == '3' && str[2] == '2' && (prefix || str[3] == 0)) { + return Type::f32; + } + if (str[1] == '6' && str[2] == '4' && (prefix || str[3] == 0)) { + return Type::f64; + } + } + if (str[0] == 'v') { + if (str[1] == '1' && str[2] == '2' && str[3] == '8' && + (prefix || str[4] == 0)) { + return Type::v128; + } + } + if (strncmp(str, "funcref", 7) == 0 && (prefix || str[7] == 0)) { + return Type::funcref; + } + if (strncmp(str, "externref", 9) == 0 && (prefix || str[9] == 0)) { + return Type::externref; + } + if (strncmp(str, "exnref", 6) == 0 && (prefix || str[6] == 0)) { + return Type::exnref; + } + if (strncmp(str, "anyref", 6) == 0 && (prefix || str[6] == 0)) { + return Type::anyref; + } + if (strncmp(str, "eqref", 5) == 0 && (prefix || str[5] == 0)) { + return Type::eqref; + } + if (strncmp(str, "i31ref", 6) == 0 && (prefix || str[6] == 0)) { + return Type::i31ref; + } + if (allowError) { + return Type::none; + } + throw ParseException(std::string("invalid wasm type: ") + str); +} + +HeapType SExpressionWasmBuilder::stringToHeapType(const char* str, + bool prefix) { + if (str[0] == 'a') { + if (str[1] == 'n' && str[2] == 'y' && (prefix || str[3] == 0)) { + return HeapType::AnyKind; + } + } + if (str[0] == 'e') { + if (str[1] == 'q' && (prefix || str[2] == 0)) { + return HeapType::EqKind; + } + if (str[1] == 'x') { + if (str[2] == 'n' && (prefix || str[3] == 0)) { + return HeapType::ExnKind; + } + if (str[2] == 't' && str[3] == 'e' && str[4] == 'r' && str[5] == 'n' && + (prefix || str[6] == 0)) { + return HeapType::ExternKind; + } + } + } + if (str[0] == 'i') { + if (str[1] == '3' && str[2] == '1' && (prefix || str[3] == 0)) { + return HeapType::I31Kind; + } + } + if (str[0] == 'f') { + if (str[1] == 'u' && str[2] == 'n' && str[3] == 'c' && + (prefix || str[4] == 0)) { + return HeapType::FuncKind; + } + } + throw ParseException(std::string("invalid wasm heap type: ") + str); +} + +Type SExpressionWasmBuilder::elementToType(Element& s) { + if (s.isStr()) { + return stringToType(s.str(), false, false); + } + auto& tuple = s.list(); + std::vector types; + for (size_t i = 0; i < s.size(); ++i) { + types.push_back(stringToType(tuple[i]->str())); + } + return Type(types); +} + +Type SExpressionWasmBuilder::stringToLaneType(const char* str) { + if (strcmp(str, "i8x16") == 0) { + return Type::i32; + } + if (strcmp(str, "i16x8") == 0) { + return Type::i32; + } + if (strcmp(str, "i32x4") == 0) { + return Type::i32; + } + if (strcmp(str, "i64x2") == 0) { + return Type::i64; + } + if (strcmp(str, "f32x4") == 0) { + return Type::f32; + } + if (strcmp(str, "f64x2") == 0) { + return Type::f64; + } + return Type::none; +} + +Function::DebugLocation +SExpressionWasmBuilder::getDebugLocation(const SourceLocation& loc) { + IString file = loc.filename; + auto& debugInfoFileNames = wasm.debugInfoFileNames; + auto iter = debugInfoFileIndices.find(file); + if (iter == debugInfoFileIndices.end()) { + Index index = debugInfoFileNames.size(); + debugInfoFileNames.push_back(file.c_str()); + debugInfoFileIndices[file] = index; + } + uint32_t fileIndex = debugInfoFileIndices[file]; + return {fileIndex, loc.line, loc.column}; +} + +Expression* SExpressionWasmBuilder::parseExpression(Element& s) { + Expression* result = makeExpression(s); + if (s.startLoc && currFunction) { + currFunction->debugLocations[result] = getDebugLocation(*s.startLoc); + } + return result; +} + +Expression* SExpressionWasmBuilder::makeExpression(Element& s){ +#define INSTRUCTION_PARSER +#include "gen-s-parser.inc" +} + +Expression* SExpressionWasmBuilder::makeUnreachable() { + return allocator.alloc(); +} + +Expression* SExpressionWasmBuilder::makeNop() { return allocator.alloc(); } + +Expression* SExpressionWasmBuilder::makeBinary(Element& s, BinaryOp op) { + auto ret = allocator.alloc(); + ret->op = op; + ret->left = parseExpression(s[1]); + ret->right = parseExpression(s[2]); + ret->finalize(); + return ret; +} + +Expression* SExpressionWasmBuilder::makeUnary(Element& s, UnaryOp op) { + auto ret = allocator.alloc(); + ret->op = op; + ret->value = parseExpression(s[1]); + ret->finalize(); + return ret; +} + +Expression* SExpressionWasmBuilder::makeSelect(Element& s) { + auto ret = allocator.alloc