diff --git a/README.md b/README.md --- a/README.md +++ b/README.md @@ -16,7 +16,7 @@ | Haskell bindings version | Bundled Binaryen version | | ------------------------ | ------------------------ | -| 0.0.5.\* | version_98 | +| 0.0.6.\* | version_99 | 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 @@ -28,6 +28,7 @@ | 0.0.2.\* | version_94 | | 0.0.3.\* | version_96 | | 0.0.4.\* | version_97 | +| 0.0.5.\* | version_98 | ## How to build diff --git a/binaryen.cabal b/binaryen.cabal --- a/binaryen.cabal +++ b/binaryen.cabal @@ -4,10 +4,10 @@ -- -- see: https://github.com/sol/hpack -- --- hash: dd229f4cad11bdebeaef89df68685de75858bc5d1ec3d969f606f0519e5e34b8 +-- hash: 15122c50a2315bce9fd4a209364778dc7a50ec2775a053a7501cd0a59659de50 name: binaryen -version: 0.0.5.0 +version: 0.0.6.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 @@ -28,10 +28,11 @@ binaryen/LICENSE binaryen/media/example.png binaryen/README.md + binaryen/requirements-dev.txt binaryen/scripts/__init__.py + binaryen/scripts/binaryen-lit.in 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 @@ -40,7 +41,7 @@ binaryen/scripts/fuzz_relooper.py binaryen/scripts/fuzz_shell.js binaryen/scripts/gen-s-parser.py - binaryen/scripts/process_optimize_instructions.py + binaryen/scripts/not.py binaryen/scripts/storage.py binaryen/scripts/strip_local_names.py binaryen/scripts/test/__init__.py @@ -57,10 +58,7 @@ 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 @@ -120,6 +118,8 @@ binaryen/src/ir/manipulation.h binaryen/src/ir/match.h binaryen/src/ir/memory-utils.h + binaryen/src/ir/module-splitting.cpp + binaryen/src/ir/module-splitting.h binaryen/src/ir/module-utils.h binaryen/src/ir/names.h binaryen/src/ir/parents.h @@ -155,7 +155,6 @@ 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 @@ -170,6 +169,7 @@ binaryen/src/passes/LocalCSE.cpp binaryen/src/passes/LogExecution.cpp binaryen/src/passes/LoopInvariantCodeMotion.cpp + binaryen/src/passes/Memory64Lowering.cpp binaryen/src/passes/MemoryPacking.cpp binaryen/src/passes/MergeBlocks.cpp binaryen/src/passes/MergeLocals.cpp @@ -199,14 +199,12 @@ 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 @@ -246,6 +244,7 @@ binaryen/src/support/safe_integer.h binaryen/src/support/small_vector.h binaryen/src/support/sorted_vector.h + binaryen/src/support/space.h binaryen/src/support/string.h binaryen/src/support/threads.cpp binaryen/src/support/threads.h @@ -270,17 +269,19 @@ binaryen/src/tools/wasm-opt.cpp binaryen/src/tools/wasm-reduce.cpp binaryen/src/tools/wasm-shell.cpp + binaryen/src/tools/wasm-split.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-delegations-fields.h + binaryen/src/wasm-delegations.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 @@ -313,7 +314,6 @@ 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 @@ -446,7 +446,6 @@ 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 @@ -457,13 +456,8 @@ 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 @@ -480,7 +474,6 @@ 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 @@ -489,8 +482,12 @@ binaryen/test/example/cpp-threads.txt binaryen/test/example/cpp-unit.cpp binaryen/test/example/cpp-unit.txt + binaryen/test/example/hash.cpp + binaryen/test/example/hash.txt binaryen/test/example/match.cpp binaryen/test/example/match.txt + binaryen/test/example/module-splitting.cpp + binaryen/test/example/module-splitting.txt binaryen/test/example/relooper-fuzz.c binaryen/test/example/relooper-fuzz.txt binaryen/test/example/relooper-fuzz1.c @@ -513,8 +510,12 @@ binaryen/test/example/relooper-merge7.txt binaryen/test/example/small_vector.cpp binaryen/test/example/small_vector.txt + binaryen/test/example/space.cpp + binaryen/test/example/space.txt binaryen/test/example/stack-utils.cpp binaryen/test/example/stack-utils.txt + binaryen/test/example/type-builder.cpp + binaryen/test/example/type-builder.txt binaryen/test/example/typeinfo.cpp binaryen/test/example/typeinfo.txt binaryen/test/exception-handling.wast @@ -525,6 +526,10 @@ binaryen/test/export-import.wast.from-wast binaryen/test/export-import.wast.fromBinary binaryen/test/export-import.wast.fromBinary.noDebugInfo + binaryen/test/extended-names.wast + binaryen/test/extended-names.wast.from-wast + binaryen/test/extended-names.wast.fromBinary + binaryen/test/extended-names.wast.fromBinary.noDebugInfo binaryen/test/externref.wast.from-wast binaryen/test/externref.wast.fromBinary binaryen/test/externref.wast.fromBinary.noDebugInfo @@ -563,16 +568,18 @@ binaryen/test/grow_memory.wast.from-wast binaryen/test/grow_memory.wast.fromBinary binaryen/test/grow_memory.wast.fromBinary.noDebugInfo + binaryen/test/heap-types.wast + binaryen/test/heap-types.wast.from-wast + binaryen/test/heap-types.wast.fromBinary + binaryen/test/heap-types.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 @@ -581,7 +588,6 @@ 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 @@ -597,11 +603,27 @@ binaryen/test/linker/foo.c binaryen/test/linker/main.c binaryen/test/linker/quux.c + binaryen/test/lit/CMakeLists.txt + binaryen/test/lit/lit.cfg.py + binaryen/test/lit/lit.site.cfg.py.in + binaryen/test/lit/parse-error.wast + binaryen/test/lit/validation/shared-memory.wast + binaryen/test/lit/wasm-emscripten-finalize/bigint.wat + binaryen/test/lit/wasm-emscripten-finalize/passive-pic.wat + binaryen/test/lit/wasm-split/basic.wast + binaryen/test/lit/wasm-split/call_exports.mjs + binaryen/test/lit/wasm-split/export-name-already-exists.wast + binaryen/test/lit/wasm-split/initial-table.wast + binaryen/test/lit/wasm-split/instrument-funcs.wast + binaryen/test/lit/wasm-split/instrument-memory-too-small.wast + binaryen/test/lit/wasm-split/invalid-options.wast + binaryen/test/lit/wasm-split/mismatched-hashes.wast + binaryen/test/lit/wasm-split/name-collision.wast + binaryen/test/lit/wasm-split/profile-guided.wast + binaryen/test/lit/wasm-split/verbose.wast 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 @@ -609,6 +631,9 @@ 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_asm64.cpp + binaryen/test/lld/em_asm64.wat + binaryen/test/lld/em_asm64.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 @@ -621,8 +646,6 @@ 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 @@ -691,8 +714,6 @@ 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 @@ -739,7 +760,6 @@ 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 @@ -758,8 +778,6 @@ 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 @@ -825,14 +843,14 @@ 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/dae_all-features.txt + binaryen/test/passes/dae_all-features.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/dce_vacuum_remove-unused-names.bin.txt + binaryen/test/passes/dce_vacuum_remove-unused-names.txt + binaryen/test/passes/dce_vacuum_remove-unused-names.wasm + binaryen/test/passes/dce_vacuum_remove-unused-names.wast binaryen/test/passes/dealign.txt binaryen/test/passes/dealign.wast binaryen/test/passes/dealign64.passes @@ -840,8 +858,8 @@ 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/directize_all-features.txt + binaryen/test/passes/directize_all-features.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 @@ -908,6 +926,8 @@ 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/fpcast-emu_pass-arg=max-func-params@5.txt + binaryen/test/passes/fpcast-emu_pass-arg=max-func-params@5.wast binaryen/test/passes/func-metrics.txt binaryen/test/passes/func-metrics.wast binaryen/test/passes/fuzz-exec_all-features.txt @@ -943,8 +963,8 @@ 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-locals_all-features_disable-typed-function-references.txt + binaryen/test/passes/instrument-locals_all-features_disable-typed-function-references.wast binaryen/test/passes/instrument-memory.txt binaryen/test/passes/instrument-memory.wast binaryen/test/passes/instrument-memory64.passes @@ -967,6 +987,10 @@ 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/memory-packing_all-features_zero-filled-memory.txt + binaryen/test/passes/memory-packing_all-features_zero-filled-memory.wast + binaryen/test/passes/memory64-lowering_enable-memory64_enable-bulk-memory.txt + binaryen/test/passes/memory64-lowering_enable-memory64_enable-bulk-memory.wast binaryen/test/passes/merge-blocks.txt binaryen/test/passes/merge-blocks.wast binaryen/test/passes/merge-blocks_remove-unused-brs.txt @@ -1017,6 +1041,10 @@ 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_all-features.txt + binaryen/test/passes/O_all-features.wast + binaryen/test/passes/O_all-features_ignore-implicit-traps.txt + binaryen/test/passes/O_all-features_ignore-implicit-traps.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 @@ -1025,14 +1053,20 @@ 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_fuzz-exec.txt + binaryen/test/passes/optimize-instructions_fuzz-exec.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/Oz_fuzz-exec_all-features.txt + binaryen/test/passes/Oz_fuzz-exec_all-features.wast binaryen/test/passes/pick-load-signs.txt binaryen/test/passes/pick-load-signs.wast + binaryen/test/passes/pick-load-signs_all-features.txt + binaryen/test/passes/pick-load-signs_all-features.wast binaryen/test/passes/post-assemblyscript-finalize.txt binaryen/test/passes/post-assemblyscript-finalize.wast binaryen/test/passes/post-assemblyscript.txt @@ -1102,6 +1136,9 @@ binaryen/test/passes/reverse_dwarf_abbrevs.wasm binaryen/test/passes/roundtrip.txt binaryen/test/passes/roundtrip.wast + binaryen/test/passes/roundtrip_signed.bin.txt + binaryen/test/passes/roundtrip_signed.passes + binaryen/test/passes/roundtrip_signed.wasm binaryen/test/passes/rse_all-features.txt binaryen/test/passes/rse_all-features.wast binaryen/test/passes/safe-heap_disable-simd.txt @@ -1113,10 +1150,15 @@ 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/safe-heap_start-function.passes + binaryen/test/passes/safe-heap_start-function.txt + binaryen/test/passes/safe-heap_start-function.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-globals_all-features_fuzz-exec.txt + binaryen/test/passes/simplify-globals_all-features_fuzz-exec.wast binaryen/test/passes/simplify-locals-nonesting.txt binaryen/test/passes/simplify-locals-nonesting.wast binaryen/test/passes/simplify-locals-nostructure.txt @@ -1133,8 +1175,6 @@ 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 @@ -1159,7 +1199,8 @@ 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/translate-to-fuzz_all-features_metrics_noprint.txt + binaryen/test/passes/translate-to-fuzz_all-features_metrics_noprint.wast binaryen/test/passes/trap-mode-clamp.txt binaryen/test/passes/trap-mode-clamp.wast binaryen/test/passes/trap-mode-js.txt @@ -1389,12 +1430,10 @@ 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/typed-function-references.wast + binaryen/test/typed-function-references.wast.from-wast + binaryen/test/typed-function-references.wast.fromBinary + binaryen/test/typed-function-references.wast.fromBinary.noDebugInfo binaryen/test/unit.wast.from-wast binaryen/test/unit.wast.fromBinary binaryen/test/unit.wast.fromBinary.noDebugInfo @@ -1417,7 +1456,9 @@ 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/hello_world.wat binaryen/test/unit/input/mutable_globals_target_feature.wasm + binaryen/test/unit/input/random_data.txt 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 @@ -1428,9 +1469,9 @@ 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_initial_fuzz.py binaryen/test/unit/test_memory_packing.py binaryen/test/unit/test_poppy_validation.py binaryen/test/unit/test_stack_ir.py @@ -1442,7 +1483,6 @@ 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 @@ -1453,12 +1493,10 @@ 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 @@ -1990,6 +2028,7 @@ binaryen/src/ir/ExpressionAnalyzer.cpp binaryen/src/ir/ExpressionManipulator.cpp binaryen/src/ir/LocalGraph.cpp + binaryen/src/ir/module-splitting.cpp binaryen/src/ir/ReFinalize.cpp binaryen/src/ir/stack-utils.cpp binaryen/src/passes/AlignmentLowering.cpp @@ -2008,7 +2047,6 @@ 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 @@ -2022,6 +2060,7 @@ binaryen/src/passes/LocalCSE.cpp binaryen/src/passes/LogExecution.cpp binaryen/src/passes/LoopInvariantCodeMotion.cpp + binaryen/src/passes/Memory64Lowering.cpp binaryen/src/passes/MemoryPacking.cpp binaryen/src/passes/MergeBlocks.cpp binaryen/src/passes/MergeLocals.cpp @@ -2049,14 +2088,12 @@ 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 diff --git a/binaryen/CHANGELOG.md b/binaryen/CHANGELOG.md --- a/binaryen/CHANGELOG.md +++ b/binaryen/CHANGELOG.md @@ -15,6 +15,21 @@ Current Trunk ------------- +- `RefFunc` C and JS API constructors (`BinaryenRefFunc` and `ref.func` + respectively) now take an extra `type` parameter, similar to `RefNull`. This + is necessary for typed function references support. +- JS API functions for atomic notify/wait instructions are renamed. + - `module.atomic.notify` -> `module.memory.atomic.notify` + - `module.i32.atomic.wait` -> `module.memory.atomic.wait32` + - `module.i64.atomic.wait` -> `module.memory.atomic.wait64` +- Remove old/broken SpollPointers pass. This pass: Spills values that might be + pointers to the C stack. This allows Boehm-style GC to see them properly. + This can be revived if needed from git history (#3261). +- Make `NUM_PARAMS` in `FuncCastEmulation` a runtime configuration option named + `max-func-params`. This defaults to the original value of 16. +- `BinaryenGetFunction`, `BinaryenGetGlobal` and `BinaryenGetEvent` now return + `NULL` instead of aborting when the respective element does not yet exist. + v98 --- diff --git a/binaryen/CMakeLists.txt b/binaryen/CMakeLists.txt --- a/binaryen/CMakeLists.txt +++ b/binaryen/CMakeLists.txt @@ -82,7 +82,7 @@ set(_install_name_dir INSTALL_NAME_DIR "@rpath") set(_install_rpath "@loader_path/../lib") elseif(UNIX) - set(_install_rpath "\$ORIGIN/../lib") + set(_install_rpath "\$ORIGIN/../${CMAKE_INSTALL_LIBDIR}") if(${CMAKE_SYSTEM_NAME} MATCHES "(FreeBSD|DragonFly)") set_property(TARGET ${name} APPEND_STRING PROPERTY LINK_FLAGS " -Wl,-z,origin ") @@ -214,6 +214,7 @@ add_compile_flag("-Wextra") add_compile_flag("-Wno-unused-parameter") add_compile_flag("-fno-omit-frame-pointer") + add_compile_flag("-fno-rtti") # 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") @@ -221,6 +222,7 @@ add_compile_flag("-Wswitch") # we explicitly expect this in the code if(WIN32) add_compile_flag("-D_GNU_SOURCE") + add_compile_flag("-D__STDC_FORMAT_MACROS") add_link_flag("-Wl,--stack,8388608") elseif(NOT EMSCRIPTEN) add_compile_flag("-fPIC") @@ -276,6 +278,9 @@ add_subdirectory(src/wasm) add_subdirectory(third_party) +# Configure lit tests +add_subdirectory(test/lit) + # Object files set(binaryen_objs $ @@ -331,6 +336,7 @@ 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_add_executable(wasm-split src/tools/wasm-split.cpp) # binaryen.js @@ -388,3 +394,5 @@ set_property(TARGET binaryen_js PROPERTY CXX_STANDARD_REQUIRED ON) install(TARGETS binaryen_js DESTINATION ${CMAKE_INSTALL_BINDIR}) endif() + +configure_file(scripts/binaryen-lit.in ${CMAKE_BINARY_DIR}/bin/binaryen-lit @ONLY) diff --git a/binaryen/auto_update_tests.py b/binaryen/auto_update_tests.py --- a/binaryen/auto_update_tests.py +++ b/binaryen/auto_update_tests.py @@ -29,27 +29,14 @@ 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) + for src in shared.get_tests(shared.get_test_dir('example')): + basename = os.path.basename(src) 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 + expected = os.path.splitext(src)[0] + '.txt' # windows + gcc will need some work if shared.skip_if_on_windows('gcc'): return diff --git a/binaryen/check.py b/binaryen/check.py --- a/binaryen/check.py +++ b/binaryen/check.py @@ -29,11 +29,6 @@ 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() @@ -47,7 +42,7 @@ def run_help_tests(): print('[ checking --help is useful... ]\n') - not_executable_suffix = ['.txt', '.js', '.ilk', '.pdb', '.dll', '.wasm', '.manifest'] + not_executable_suffix = ['.txt', '.js', '.ilk', '.pdb', '.dll', '.wasm', '.manifest', 'binaryen-lit'] 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) @@ -291,37 +286,24 @@ 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: + cmd = ['-I' + os.path.join(shared.options.binaryen_root, 't'), '-g', '-pthread', '-o', output_file] + if not t.endswith(('.c', '.cpp')): continue + src = os.path.join(shared.get_test_dir('example'), t) + expected = os.path.join(shared.get_test_dir('example'), '.'.join(t.split('.')[:-1]) + '.txt') + # build the C file separately + libpath = shared.options.binaryen_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] print(' ', t, src, expected) if os.environ.get('COMPILER_FLAGS'): for f in os.environ.get('COMPILER_FLAGS').split(' '): @@ -346,6 +328,18 @@ raise Exception("unittest failed") +def run_lit(): + lit_script = os.path.join(shared.options.binaryen_bin, 'binaryen-lit') + lit_tests = os.path.join(shared.options.binaryen_root, 'test', 'lit') + # lit expects to be run as its own executable + cmd = [sys.executable, lit_script, lit_tests, '-vv'] + result = subprocess.run(cmd) + if result.returncode != 0: + shared.num_failures += 1 + if shared.options.abort_on_first_failure and shared.num_failures: + raise Exception("lit test failed") + + TEST_SUITES = OrderedDict([ ('help-messages', run_help_tests), ('wasm-opt', wasm_opt.test_wasm_opt), @@ -363,6 +357,7 @@ ('unit', run_unittest), ('binaryenjs', binaryenjs.test_binaryen_js), ('binaryenjs_wasm', binaryenjs.test_binaryen_wasm), + ('lit', run_lit), ]) diff --git a/binaryen/requirements-dev.txt b/binaryen/requirements-dev.txt new file mode 100644 --- /dev/null +++ b/binaryen/requirements-dev.txt @@ -0,0 +1,8 @@ +# These requirements are only needed for developers who want to run the test +# suite or flake8, not for end users. + +# Install with `pip3 install -r requirements-dev.txt` + +flake8==3.7.8 +filecheck==0.0.17 +lit==0.11.0.post1 diff --git a/binaryen/scripts/binaryen-lit.in b/binaryen/scripts/binaryen-lit.in new file mode 100644 --- /dev/null +++ b/binaryen/scripts/binaryen-lit.in @@ -0,0 +1,33 @@ +#!/usr/bin/env python3 +# +# 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. + +import os +from lit.main import main + +# A simple wrapper around `lit` test running. Loosely based on +# llvm's llvm-lit script + +builtin_parameters = { + 'config_map': { + os.path.normcase(os.path.normpath('@CMAKE_SOURCE_DIR@/test/lit/lit.cfg.py')): + os.path.normcase(os.path.normpath('@CMAKE_BINARY_DIR@/test/lit/lit.site.cfg.py')) + } +} + +print(builtin_parameters) + +if __name__ == '__main__': + main(builtin_parameters) diff --git a/binaryen/scripts/clean_c_api_trace.py b/binaryen/scripts/clean_c_api_trace.py deleted file mode 100644 --- a/binaryen/scripts/clean_c_api_trace.py +++ /dev/null @@ -1,37 +0,0 @@ -#!/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/fuzz_opt.py b/binaryen/scripts/fuzz_opt.py --- a/binaryen/scripts/fuzz_opt.py +++ b/binaryen/scripts/fuzz_opt.py @@ -28,7 +28,9 @@ import traceback from test import shared +from test import support + assert sys.version_info.major == 3, 'requires Python 3!' # parameters @@ -68,9 +70,10 @@ 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(cmd, stderr=None, silent=False): + if not silent: + print(' '.join(cmd)) + return subprocess.check_output(cmd, stderr=stderr, text=True) def run_unchecked(cmd): @@ -102,12 +105,11 @@ 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: + # 1/3 the time apply all the possible opts, 1/3 none of them, to maximize + # coverage both ways, and 1/3 pick each one randomly + if random.random() < 0.33333: FEATURE_OPTS += POSSIBLE_FEATURE_OPTS - else: + elif random.random() < 0.5: for possible in POSSIBLE_FEATURE_OPTS: if random.random() < 0.5: FEATURE_OPTS.append(possible) @@ -116,15 +118,19 @@ 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(): + # a list of the optimizations to run on the wasm + global FUZZ_OPTS + # a boolean whether NaN values are allowed, or we de-NaN them + global NANS -def randomize_fuzz_settings(): - global FUZZ_OPTS, NANS, OOB, LEGALIZE + # a boolean whether out of bounds operations are allowed, or we bounds-enforce them + global OOB + + # a boolean whether we legalize the wasm for JS + global LEGALIZE + FUZZ_OPTS = [] if random.random() < 0.5: NANS = True @@ -141,25 +147,93 @@ 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). + print('randomized settings (NaNs, OOB, legalize):', NANS, OOB, LEGALIZE) + + +IMPORTANT_INITIAL_CONTENTS = [ + os.path.join('passes', 'optimize-instructions_all-features.wast'), + os.path.join('passes', 'optimize-instructions_fuzz-exec.wast'), +] +IMPORTANT_INITIAL_CONTENTS = [os.path.join(shared.get_test_dir('.'), t) for t in IMPORTANT_INITIAL_CONTENTS] + + +def pick_initial_contents(): + # if we use an initial wasm file's contents as the basis for the + # fuzzing, then that filename, or None if we start entirely from scratch + global INITIAL_CONTENTS + + INITIAL_CONTENTS = None + # half the time don't use any initial contents 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) + return + # some of the time use initial contents that are known to be especially + # important + if random.random() < 0.5: + test_name = random.choice(IMPORTANT_INITIAL_CONTENTS) + else: + test_name = random.choice(all_tests) + print('initial contents:', test_name) + assert os.path.exists(test_name) + # tests that check validation errors are not helpful for us + if '.fail.' in test_name: + print('initial contents is just a .fail test') + return + if os.path.basename(test_name) in [ + # contains too many segments to run in a wasm VM + 'limit-segments_disable-bulk-memory.wast', + # https://github.com/WebAssembly/binaryen/issues/3203 + 'simd.wast', + # corner cases of escaping of names is not interesting + 'names.wast', + # huge amount of locals that make it extremely slow + 'too_much_for_liveness.wasm' + ]: + print('initial contents is disallowed') + return + if test_name.endswith('.wast'): + # this can contain multiple modules, pick one + split_parts = support.split_wast(test_name) + if len(split_parts) > 1: + index = random.randint(0, len(split_parts) - 1) + chosen = split_parts[index] + module, asserts = chosen + if not module: + # there is no module in this choice (just asserts), ignore it + print('initial contents has no module') + return + test_name = 'initial.wat' + with open(test_name, 'w') as f: + f.write(module) + print(' picked submodule %d from multi-module wast' % index) + global FEATURE_OPTS + FEATURE_OPTS += [ + # has not been enabled in the fuzzer yet + '--disable-exception-handling', + # has not been fuzzed in general yet + '--disable-memory64', + # has not been fuzzed in general yet + '--disable-gc', + # DWARF is incompatible with multivalue atm; it's more important to + # fuzz multivalue since we aren't actually fuzzing DWARF here + '--strip-dwarf', + ] + + # the given wasm may not work with the chosen feature opts. for example, if + # we pick atomics.wast but want to run with --disable-atomics, then we'd + # error. test the wasm. + try: + run([in_bin('wasm-opt'), test_name] + FEATURE_OPTS, + stderr=subprocess.PIPE, + silent=True) + except Exception: + print('(initial contents not valid for features, ignoring)') + return + + INITIAL_CONTENTS = test_name + + # Test outputs we want to ignore are marked this way. IGNORE = '[binaryen-fuzzer-ignore]' @@ -302,14 +376,27 @@ 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) +V8_LIFTOFF_ARGS = ['--liftoff', '--no-wasm-tier-up'] -def run_d8_wasm(wasm): - return run_d8_js(in_binaryen('scripts', 'fuzz_shell.js'), [wasm]) +# default to running with liftoff enabled, because we need to pick either +# liftoff or turbofan for consistency (otherwise running the same command twice +# may have different results due to NaN nondeterminism), and liftoff is faster +# for small things +def run_d8_js(js, args=[], liftoff=True): + cmd = [shared.V8] + shared.V8_OPTS + if liftoff: + cmd += V8_LIFTOFF_ARGS + cmd += [js] + if args: + cmd += ['--'] + args + return run_vm(cmd) +def run_d8_wasm(wasm, liftoff=True): + return run_d8_js(in_binaryen('scripts', 'fuzz_shell.js'), [wasm], liftoff=liftoff) + + class TestCaseHandler: # how frequent this handler will be run. 1 means always run it, 0.5 means half the # time @@ -335,19 +422,6 @@ 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 @@ -362,23 +436,57 @@ def __init__(self): super(CompareVMs, self).__init__() - def byn_run(wasm): - return run_bynterp(wasm, ['--fuzz-exec-before']) + class BinaryenInterpreter: + name = 'binaryen interpreter' - 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 run(self, wasm): + return run_bynterp(wasm, ['--fuzz-exec-before']) - def yes(): - return True + def can_run(self, wasm): + return True - def if_legal_and_no_nans(): - return LEGALIZE and not NANS + def can_compare_to_self(self): + return True - def if_no_nans(): - return not NANS + def can_compare_to_others(self): + return True - class Wasm2C(VM): + class D8: + name = 'd8' + + def run(self, wasm, extra_d8_flags=[]): + run([in_bin('wasm-opt'), wasm, '--emit-js-wrapper=' + wasm + '.js'] + FEATURE_OPTS) + return run_vm([shared.V8, wasm + '.js'] + shared.V8_OPTS + extra_d8_flags + ['--', wasm]) + + def can_run(self, wasm): + # INITIAL_CONTENT is disallowed because some initial spec testcases + # have names that require mangling, see + # https://github.com/WebAssembly/binaryen/pull/3216 + return not INITIAL_CONTENTS + + def can_compare_to_self(self): + # With nans, VM differences can confuse us, so only very simple VMs + # can compare to themselves after opts in that case. + return not NANS + + def can_compare_to_others(self): + # If not legalized, the JS will fail immediately, so no point to + # compare to others. + return LEGALIZE and not NANS + + class D8Liftoff(D8): + name = 'd8_liftoff' + + def run(self, wasm): + return super(D8Liftoff, self).run(wasm, extra_d8_flags=V8_LIFTOFF_ARGS) + + class D8TurboFan(D8): + name = 'd8_turbofan' + + def run(self, wasm): + return super(D8TurboFan, self).run(wasm, extra_d8_flags=['--no-liftoff']) + + class Wasm2C: name = 'wasm2c' def __init__(self): @@ -433,7 +541,11 @@ 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'] + compile_cmd = ['emcc', 'main.c', 'wasm.c', + os.path.join(self.wasm2c_dir, 'wasm-rt-impl.c'), + '-I' + self.wasm2c_dir, + '-lm', + '-s', 'ALLOW_MEMORY_GROWTH'] # disable the signal handler: emcc looks like unix, but wasm has # no signals compile_cmd += ['-DWASM_RT_MEMCHECK_SIGNAL_HANDLER=0'] @@ -464,14 +576,8 @@ # 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(), - ] + self.vms = [BinaryenInterpreter(), D8(), D8Liftoff(), D8TurboFan(), + Wasm2C(), Wasm2C2Wasm()] def handle_pair(self, input, before_wasm, after_wasm, opts): before = self.run_vms(before_wasm) @@ -483,6 +589,7 @@ vm_results = {} for vm in self.vms: if vm.can_run(wasm): + print(f'[CompareVMs] running {vm.name}') vm_results[vm] = fix_output(vm.run(wasm)) # compare between the vms on this specific input @@ -635,6 +742,13 @@ return run_vm([shared.NODEJS, js_file, 'a.wasm']) def can_run_on_feature_opts(self, feature_opts): + # TODO: properly handle memory growth. right now the wasm2js handler + # uses --emscripten which assumes the Memory is created before, and + # wasm2js.js just starts with a size of 1 and no limit. We should switch + # to non-emscripten mode or adding memory information, or check + # specifically for growth here + if INITIAL_CONTENTS: + return False 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']]) @@ -692,6 +806,15 @@ return all([x in feature_opts for x in ['--disable-exception-handling', '--disable-simd', '--disable-tail-call', '--disable-reference-types', '--disable-multivalue', '--disable-gc']]) +# Check that the text format round-trips without error. +class RoundtripText(TestCaseHandler): + frequency = 0.05 + + def handle(self, wasm): + run([in_bin('wasm-dis'), wasm, '-o', 'a.wast']) + run([in_bin('wasm-opt'), 'a.wast'] + FEATURE_OPTS) + + # The global list of all test case handlers testcase_handlers = [ FuzzExec(), @@ -699,14 +822,29 @@ CheckDeterminism(), Wasm2JS(), Asyncify(), + RoundtripText() ] +test_suffixes = ['*.wasm', '*.wast', '*.wat'] +core_tests = shared.get_tests(shared.get_test_dir('.'), test_suffixes) +passes_tests = shared.get_tests(shared.get_test_dir('passes'), test_suffixes) +spec_tests = shared.get_tests(shared.get_test_dir('spec'), test_suffixes) +wasm2js_tests = shared.get_tests(shared.get_test_dir('wasm2js'), test_suffixes) +lld_tests = shared.get_tests(shared.get_test_dir('lld'), test_suffixes) +unit_tests = shared.get_tests(shared.get_test_dir(os.path.join('unit', 'input')), test_suffixes) +all_tests = core_tests + passes_tests + spec_tests + wasm2js_tests + lld_tests + unit_tests + + # Do one test, given an input file for -ttf and some optimizations to run -def test_one(random_input, opts, given_wasm): +def test_one(random_input, given_wasm): randomize_pass_debug() randomize_feature_opts() randomize_fuzz_settings() + pick_initial_contents() + + opts = randomize_opt_flags() + print('randomized opts:', ' '.join(opts)) print() if given_wasm: @@ -719,6 +857,8 @@ # 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 INITIAL_CONTENTS: + generate_command += ['--initial-fuzz=' + INITIAL_CONTENTS] if PRINT_WATS: printed = run(generate_command + ['--print']) with open('a.printed.wast', 'w') as f: @@ -840,10 +980,16 @@ # core opts while 1: choice = random.choice(opt_choices) - if '--flatten' in choice: + if '--flatten' in choice or '-O4' in choice: if has_flatten: print('avoiding multiple --flatten in a single command, due to exponential overhead') continue + if '--disable-exception-handling' not in FEATURE_OPTS: + print('avoiding --flatten due to exception catching which does not support it yet') + continue + if INITIAL_CONTENTS and os.path.getsize(INITIAL_CONTENTS) > 2000: + print('avoiding --flatten due using a large amount of initial contents, which may blow up') + continue else: has_flatten = True flag_groups.append(choice) @@ -925,10 +1071,13 @@ 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)) + # remove the generated wasm file, so that we can tell if the fuzzer + # fails to create one + if os.path.exists('a.wasm'): + os.remove('a.wasm') + # run an iteration of the fuzzer try: - total_wasm_size += test_one(raw_input_data, opts, given_wasm) + total_wasm_size += test_one(raw_input_data, given_wasm) except KeyboardInterrupt: print('(stopping by user request)') break @@ -953,6 +1102,26 @@ # is likely to be called within wasm-reduce script itself, so # original.wasm and reduce.sh should not be overwritten. if not given_wasm: + # We can't do this if a.wasm doesn't exist, which can be the + # case if we failed to even generate the wasm. + if not os.path.exists('a.wasm'): + print('''\ +================================================================================ +You found a bug in the fuzzer itself! It failed to generate a valid wasm file +from the random input. 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" + +(We can't automatically reduce this testcase since we can only run the reducer +on valid wasm files.) +================================================================================ + ''' % {'seed': seed}) + break # 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" diff --git a/binaryen/scripts/gen-s-parser.py b/binaryen/scripts/gen-s-parser.py --- a/binaryen/scripts/gen-s-parser.py +++ b/binaryen/scripts/gen-s-parser.py @@ -201,9 +201,9 @@ ("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)"), + ("memory.atomic.notify", "makeAtomicNotify(s)"), + ("memory.atomic.wait32", "makeAtomicWait(s, Type::i32)"), + ("memory.atomic.wait64", "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)"), @@ -332,6 +332,7 @@ ("i32x4.le_u", "makeBinary(s, BinaryOp::LeUVecI32x4)"), ("i32x4.ge_s", "makeBinary(s, BinaryOp::GeSVecI32x4)"), ("i32x4.ge_u", "makeBinary(s, BinaryOp::GeUVecI32x4)"), + ("i64x2.eq", "makeBinary(s, BinaryOp::EqVecI64x2)"), ("f32x4.eq", "makeBinary(s, BinaryOp::EqVecF32x4)"), ("f32x4.ne", "makeBinary(s, BinaryOp::NeVecF32x4)"), ("f32x4.lt", "makeBinary(s, BinaryOp::LtVecF32x4)"), @@ -350,6 +351,19 @@ ("v128.xor", "makeBinary(s, BinaryOp::XorVec128)"), ("v128.andnot", "makeBinary(s, BinaryOp::AndNotVec128)"), ("v128.bitselect", "makeSIMDTernary(s, SIMDTernaryOp::Bitselect)"), + ("v8x16.signselect", "makeSIMDTernary(s, SIMDTernaryOp::SignSelectVec8x16)"), + ("v16x8.signselect", "makeSIMDTernary(s, SIMDTernaryOp::SignSelectVec16x8)"), + ("v32x4.signselect", "makeSIMDTernary(s, SIMDTernaryOp::SignSelectVec32x4)"), + ("v64x2.signselect", "makeSIMDTernary(s, SIMDTernaryOp::SignSelectVec64x2)"), + ("v128.load8_lane", "makeSIMDLoadStoreLane(s, LoadLaneVec8x16)"), + ("v128.load16_lane", "makeSIMDLoadStoreLane(s, LoadLaneVec16x8)"), + ("v128.load32_lane", "makeSIMDLoadStoreLane(s, LoadLaneVec32x4)"), + ("v128.load64_lane", "makeSIMDLoadStoreLane(s, LoadLaneVec64x2)"), + ("v128.store8_lane", "makeSIMDLoadStoreLane(s, StoreLaneVec8x16)"), + ("v128.store16_lane", "makeSIMDLoadStoreLane(s, StoreLaneVec16x8)"), + ("v128.store32_lane", "makeSIMDLoadStoreLane(s, StoreLaneVec32x4)"), + ("v128.store64_lane", "makeSIMDLoadStoreLane(s, StoreLaneVec64x2)"), + ("i8x16.popcnt", "makeUnary(s, UnaryOp::PopcntVecI8x16)"), ("i8x16.abs", "makeUnary(s, UnaryOp::AbsVecI8x16)"), ("i8x16.neg", "makeUnary(s, UnaryOp::NegVecI8x16)"), ("i8x16.any_true", "makeUnary(s, UnaryOp::AnyTrueVecI8x16)"), @@ -390,6 +404,11 @@ ("i16x8.max_s", "makeBinary(s, BinaryOp::MaxSVecI16x8)"), ("i16x8.max_u", "makeBinary(s, BinaryOp::MaxUVecI16x8)"), ("i16x8.avgr_u", "makeBinary(s, BinaryOp::AvgrUVecI16x8)"), + ("i16x8.q15mulr_sat_s", "makeBinary(s, BinaryOp::Q15MulrSatSVecI16x8)"), + ("i16x8.extmul_low_i8x16_s", "makeBinary(s, BinaryOp::ExtMulLowSVecI16x8)"), + ("i16x8.extmul_high_i8x16_s", "makeBinary(s, BinaryOp::ExtMulHighSVecI16x8)"), + ("i16x8.extmul_low_i8x16_u", "makeBinary(s, BinaryOp::ExtMulLowUVecI16x8)"), + ("i16x8.extmul_high_i8x16_u", "makeBinary(s, BinaryOp::ExtMulHighUVecI16x8)"), ("i32x4.abs", "makeUnary(s, UnaryOp::AbsVecI32x4)"), ("i32x4.neg", "makeUnary(s, UnaryOp::NegVecI32x4)"), ("i32x4.any_true", "makeUnary(s, UnaryOp::AnyTrueVecI32x4)"), @@ -406,15 +425,22 @@ ("i32x4.max_s", "makeBinary(s, BinaryOp::MaxSVecI32x4)"), ("i32x4.max_u", "makeBinary(s, BinaryOp::MaxUVecI32x4)"), ("i32x4.dot_i16x8_s", "makeBinary(s, BinaryOp::DotSVecI16x8ToVecI32x4)"), + ("i32x4.extmul_low_i16x8_s", "makeBinary(s, BinaryOp::ExtMulLowSVecI32x4)"), + ("i32x4.extmul_high_i16x8_s", "makeBinary(s, BinaryOp::ExtMulHighSVecI32x4)"), + ("i32x4.extmul_low_i16x8_u", "makeBinary(s, BinaryOp::ExtMulLowUVecI32x4)"), + ("i32x4.extmul_high_i16x8_u", "makeBinary(s, BinaryOp::ExtMulHighUVecI32x4)"), ("i64x2.neg", "makeUnary(s, UnaryOp::NegVecI64x2)"), - ("i64x2.any_true", "makeUnary(s, UnaryOp::AnyTrueVecI64x2)"), - ("i64x2.all_true", "makeUnary(s, UnaryOp::AllTrueVecI64x2)"), + ("i64x2.bitmask", "makeUnary(s, UnaryOp::BitmaskVecI64x2)"), ("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)"), + ("i64x2.extmul_low_i32x4_s", "makeBinary(s, BinaryOp::ExtMulLowSVecI64x2)"), + ("i64x2.extmul_high_i32x4_s", "makeBinary(s, BinaryOp::ExtMulHighSVecI64x2)"), + ("i64x2.extmul_low_i32x4_u", "makeBinary(s, BinaryOp::ExtMulLowUVecI64x2)"), + ("i64x2.extmul_high_i32x4_u", "makeBinary(s, BinaryOp::ExtMulHighUVecI64x2)"), ("f32x4.abs", "makeUnary(s, UnaryOp::AbsVecF32x4)"), ("f32x4.neg", "makeUnary(s, UnaryOp::NegVecF32x4)"), ("f32x4.sqrt", "makeUnary(s, UnaryOp::SqrtVecF32x4)"), @@ -481,7 +507,18 @@ ("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)"), + ("i64x2.widen_low_i32x4_s", "makeUnary(s, UnaryOp::WidenLowSVecI32x4ToVecI64x2)"), + ("i64x2.widen_high_i32x4_s", "makeUnary(s, UnaryOp::WidenHighSVecI32x4ToVecI64x2)"), + ("i64x2.widen_low_i32x4_u", "makeUnary(s, UnaryOp::WidenLowUVecI32x4ToVecI64x2)"), + ("i64x2.widen_high_i32x4_u", "makeUnary(s, UnaryOp::WidenHighUVecI32x4ToVecI64x2)"), ("v8x16.swizzle", "makeBinary(s, BinaryOp::SwizzleVec8x16)"), + ("i16x8.extadd_pairwise_i8x16_s", "makeUnary(s, UnaryOp::ExtAddPairwiseSVecI8x16ToI16x8)"), + ("i16x8.extadd_pairwise_i8x16_u", "makeUnary(s, UnaryOp::ExtAddPairwiseUVecI8x16ToI16x8)"), + ("i32x4.extadd_pairwise_i16x8_s", "makeUnary(s, UnaryOp::ExtAddPairwiseSVecI16x8ToI32x4)"), + ("i32x4.extadd_pairwise_i16x8_u", "makeUnary(s, UnaryOp::ExtAddPairwiseUVecI16x8ToI32x4)"), + # prefetch instructions + ("prefetch.t", "makePrefetch(s, PrefetchOp::PrefetchTemporal)"), + ("prefetch.nt", "makePrefetch(s, PrefetchOp::PrefetchNontemporal)"), # reference types instructions # TODO Add table instructions ("ref.null", "makeRefNull(s)"), @@ -496,6 +533,9 @@ ("tuple.make", "makeTupleMake(s)"), ("tuple.extract", "makeTupleExtract(s)"), ("pop", "makePop(s)"), + # Typed function references instructions + ("call_ref", "makeCallRef(s, /*isReturn=*/false)"), + ("return_call_ref", "makeCallRef(s, /*isReturn=*/true)"), # GC ("ref.eq", "makeRefEq(s)"), ("i31.new", "makeI31New(s)"), diff --git a/binaryen/scripts/not.py b/binaryen/scripts/not.py new file mode 100644 --- /dev/null +++ b/binaryen/scripts/not.py @@ -0,0 +1,30 @@ +#!/usr/bin/env python3 + +# 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. + +import sys +import subprocess + + +# Emulate the `not` tool from LLVM's test infrastructure for use with lit and +# FileCheck. It succeeds if the given subcommand fails and vice versa. +def main(): + cmd = sys.argv[1:] + result = subprocess.run(cmd) + sys.exit(0 if result.returncode != 0 else 1) + + +if __name__ == '__main__': + main() diff --git a/binaryen/scripts/process_optimize_instructions.py b/binaryen/scripts/process_optimize_instructions.py deleted file mode 100644 --- a/binaryen/scripts/process_optimize_instructions.py +++ /dev/null @@ -1,16 +0,0 @@ -#!/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/test/generate_lld_tests.py b/binaryen/scripts/test/generate_lld_tests.py --- a/binaryen/scripts/test/generate_lld_tests.py +++ b/binaryen/scripts/test/generate_lld_tests.py @@ -48,10 +48,10 @@ wasm_path = os.path.join(lld_path, wasm_file) wat_path = os.path.join(lld_path, wat_file) is_shared = 'shared' in src_file + is_64 = '64' 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', @@ -67,7 +67,6 @@ 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 @@ -81,6 +80,12 @@ link_cmd.append('--experimental-pic') else: link_cmd.append('--entry=main') + + if is_64: + compile_cmd.append('--target=wasm64-emscripten') + link_cmd.append('-mwasm64') + else: + compile_cmd.append('--target=wasm32-emscripten') try: support.run_command(compile_cmd) diff --git a/binaryen/scripts/test/lld.py b/binaryen/scripts/test/lld.py --- a/binaryen/scripts/test/lld.py +++ b/binaryen/scripts/test/lld.py @@ -26,8 +26,6 @@ ret += ['--side-module'] if 'standalone-wasm' in filename: ret += ['--standalone-wasm'] - if 'bigint' in filename: - ret += ['--bigint'] return ret @@ -51,7 +49,10 @@ else: continue - cmd = shared.WASM_EMSCRIPTEN_FINALIZE + [input_path, '-S'] + args + cmd = shared.WASM_EMSCRIPTEN_FINALIZE + args + if '64' in input_path: + cmd += ['--enable-memory64', '--bigint'] + cmd += [input_path, '-S'] cmd += args_for_finalize(os.path.basename(input_path)) actual = support.run_command(cmd) @@ -96,9 +97,12 @@ 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 = shared.WASM_EMSCRIPTEN_FINALIZE + ext_args + if '64' in input_path: + cmd += ['--enable-memory64', '--bigint'] + cmd += [input_path, '-S'] 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/shared.py b/binaryen/scripts/test/shared.py --- a/binaryen/scripts/test/shared.py +++ b/binaryen/scripts/test/shared.py @@ -49,15 +49,17 @@ 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).' + help=('Specifies the path to the Binaryen executables in the CMake build' + ' directory. 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-lib', dest='binaryen_lib', default='', + help=('Specifies a path to where the built Binaryen shared library resides at.' + ' Default: ./lib relative to bin specified above.')) + 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.')) @@ -123,10 +125,17 @@ options.binaryen_bin = os.path.normpath(os.path.abspath(options.binaryen_bin)) +if not options.binaryen_lib: + options.binaryen_lib = os.path.join(os.path.dirname(options.binaryen_bin), 'lib') + +options.binaryen_lib = os.path.normpath(os.path.abspath(options.binaryen_lib)) + +options.binaryen_build = os.path.dirname(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'] +wasm_dis_filenames = ['wasm-dis', 'wasm-dis.exe', 'wasm-dis.js'] 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/ ?') @@ -182,7 +191,7 @@ 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')) +NODEJS = os.getenv('NODE', which('node') or which('nodejs')) MOZJS = which('mozjs') or which('spidermonkey') V8 = which('v8') or which('d8') @@ -261,18 +270,7 @@ 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 @@ -380,10 +378,6 @@ 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: diff --git a/binaryen/scripts/test/wasm_opt.py b/binaryen/scripts/test/wasm_opt.py --- a/binaryen/scripts/test/wasm_opt.py +++ b/binaryen/scripts/test/wasm_opt.py @@ -57,7 +57,8 @@ 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('_')] + passes = [p for p in passname.split('_') if p != 'noprint'] + opts = [('--' + p if not p.startswith('O') and p != 'g' else '-' + p) for p in passes] actual = '' for module, asserts in support.split_wast(t): assert len(asserts) == 0 @@ -171,7 +172,8 @@ 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('_')] + passes = [p for p in passname.split('_') if p != 'noprint'] + opts = [('--' + p if not p.startswith('O') and p != 'g' else '-' + p) for p in passes] actual = '' for module, asserts in support.split_wast(t): assert len(asserts) == 0 diff --git a/binaryen/src/abi/abi.h b/binaryen/src/abi/abi.h deleted file mode 100644 --- a/binaryen/src/abi/abi.h +++ /dev/null @@ -1,33 +0,0 @@ -/* - * 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/stack.h b/binaryen/src/abi/stack.h deleted file mode 100644 --- a/binaryen/src/abi/stack.h +++ /dev/null @@ -1,144 +0,0 @@ -/* - * 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 deleted file mode 100644 --- a/binaryen/src/abi/wasm-object.h +++ /dev/null @@ -1,40 +0,0 @@ -/* - * 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 --- a/binaryen/src/asm_v_wasm.h +++ b/binaryen/src/asm_v_wasm.h @@ -23,26 +23,12 @@ 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; @@ -62,9 +48,6 @@ } return ret; } - -// converts an f32 to an f64 if necessary -Expression* ensureDouble(Expression* expr, MixedArena& allocator); } // namespace wasm diff --git a/binaryen/src/asmjs/asm_v_wasm.cpp b/binaryen/src/asmjs/asm_v_wasm.cpp --- a/binaryen/src/asmjs/asm_v_wasm.cpp +++ b/binaryen/src/asmjs/asm_v_wasm.cpp @@ -19,28 +19,6 @@ 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()) { @@ -102,10 +80,6 @@ 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; @@ -114,18 +88,6 @@ 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/shared-constants.cpp b/binaryen/src/asmjs/shared-constants.cpp --- a/binaryen/src/asmjs/shared-constants.cpp +++ b/binaryen/src/asmjs/shared-constants.cpp @@ -18,11 +18,6 @@ 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"); @@ -34,7 +29,6 @@ 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"); @@ -55,10 +49,10 @@ 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 TRUNC("trunc"); cashew::IString SQRT("sqrt"); cashew::IString POW("pow"); cashew::IString I32_TEMP("asm2wasm_i32_temp"); @@ -93,8 +87,6 @@ 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"); diff --git a/binaryen/src/asmjs/shared-constants.h b/binaryen/src/asmjs/shared-constants.h --- a/binaryen/src/asmjs/shared-constants.h +++ b/binaryen/src/asmjs/shared-constants.h @@ -21,11 +21,6 @@ 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; @@ -37,7 +32,6 @@ 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; @@ -58,10 +52,10 @@ 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 TRUNC; extern cashew::IString SQRT; extern cashew::IString POW; extern cashew::IString I32_TEMP; @@ -73,8 +67,8 @@ 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_CEIL; extern cashew::IString MATH_FLOOR; extern cashew::IString MATH_TRUNC; extern cashew::IString MATH_SQRT; @@ -96,8 +90,6 @@ 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; diff --git a/binaryen/src/binaryen-c.cpp b/binaryen/src/binaryen-c.cpp --- a/binaryen/src/binaryen-c.cpp +++ b/binaryen/src/binaryen-c.cpp @@ -29,7 +29,6 @@ #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" @@ -178,152 +177,14 @@ 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; -} +#define DELEGATE(CLASS_TO_VISIT) \ + BinaryenExpressionId Binaryen##CLASS_TO_VISIT##Id(void) { \ + return Expression::Id::CLASS_TO_VISIT##Id; \ + } + +#include "wasm-delegations.h" + // External kinds BinaryenExternalKind BinaryenExternalFunction(void) { @@ -562,12 +423,12 @@ 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 BinaryenAtomicRMWAdd(void) { return RMWAdd; } +BinaryenOp BinaryenAtomicRMWSub(void) { return RMWSub; } +BinaryenOp BinaryenAtomicRMWAnd(void) { return RMWAnd; } +BinaryenOp BinaryenAtomicRMWOr(void) { return RMWOr; } +BinaryenOp BinaryenAtomicRMWXor(void) { return RMWXor; } +BinaryenOp BinaryenAtomicRMWXchg(void) { return RMWXchg; } BinaryenOp BinaryenTruncSatSFloat32ToInt32(void) { return TruncSatSFloat32ToInt32; } @@ -719,8 +580,6 @@ 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; } @@ -1325,9 +1184,11 @@ Builder(*(Module*)module).makeRefIsNull((Expression*)value)); } -BinaryenExpressionRef BinaryenRefFunc(BinaryenModuleRef module, - const char* func) { - return static_cast(Builder(*(Module*)module).makeRefFunc(func)); +BinaryenExpressionRef +BinaryenRefFunc(BinaryenModuleRef module, const char* func, BinaryenType type) { + Type type_(type); + return static_cast( + Builder(*(Module*)module).makeRefFunc(func, type_)); } BinaryenExpressionRef BinaryenRefEq(BinaryenModuleRef module, @@ -1412,8 +1273,7 @@ ((Expression*)expr)->type = Type(type); } void BinaryenExpressionPrint(BinaryenExpressionRef expr) { - WasmPrinter::printExpression((Expression*)expr, std::cout); - std::cout << '\n'; + std::cout << *(Expression*)expr << '\n'; } void BinaryenExpressionFinalize(BinaryenExpressionRef expr) { ReFinalizeNode().visit((Expression*)expr); @@ -3131,7 +2991,7 @@ BinaryenIndex numVarTypes, BinaryenExpressionRef body) { auto* ret = new Function; - ret->name = name; + ret->setExplicitName(name); ret->sig = Signature(Type(params), Type(results)); for (BinaryenIndex i = 0; i < numVarTypes; i++) { ret->vars.push_back(Type(varTypes[i])); @@ -3149,21 +3009,21 @@ } BinaryenFunctionRef BinaryenGetFunction(BinaryenModuleRef module, const char* name) { - return ((Module*)module)->getFunction(name); + return ((Module*)module)->getFunctionOrNull(name); } void BinaryenRemoveFunction(BinaryenModuleRef module, const char* name) { ((Module*)module)->removeFunction(name); } -uint32_t BinaryenGetNumFunctions(BinaryenModuleRef module) { +BinaryenIndex BinaryenGetNumFunctions(BinaryenModuleRef module) { return ((Module*)module)->functions.size(); } BinaryenFunctionRef BinaryenGetFunctionByIndex(BinaryenModuleRef module, - BinaryenIndex id) { + BinaryenIndex index) { const auto& functions = ((Module*)module)->functions; - if (functions.size() <= id) { - Fatal() << "invalid function id."; + if (functions.size() <= index) { + Fatal() << "invalid function index."; } - return functions[id].get(); + return functions[index].get(); } // Globals @@ -3174,7 +3034,7 @@ int8_t mutable_, BinaryenExpressionRef init) { auto* ret = new Global(); - ret->name = name; + ret->setExplicitName(name); ret->type = Type(type); ret->mutable_ = !!mutable_; ret->init = (Expression*)init; @@ -3183,11 +3043,22 @@ } BinaryenGlobalRef BinaryenGetGlobal(BinaryenModuleRef module, const char* name) { - return ((Module*)module)->getGlobal(name); + return ((Module*)module)->getGlobalOrNull(name); } void BinaryenRemoveGlobal(BinaryenModuleRef module, const char* name) { ((Module*)module)->removeGlobal(name); } +BinaryenIndex BinaryenGetNumGlobals(BinaryenModuleRef module) { + return ((Module*)module)->globals.size(); +} +BinaryenGlobalRef BinaryenGetGlobalByIndex(BinaryenModuleRef module, + BinaryenIndex index) { + const auto& globals = ((Module*)module)->globals; + if (globals.size() <= index) { + Fatal() << "invalid global index."; + } + return globals[index].get(); +} // Events @@ -3197,7 +3068,7 @@ BinaryenType params, BinaryenType results) { auto* ret = new Event(); - ret->name = name; + ret->setExplicitName(name); ret->attribute = attribute; ret->sig = Signature(Type(params), Type(results)); ((Module*)module)->addEvent(ret); @@ -3205,7 +3076,7 @@ } BinaryenEventRef BinaryenGetEvent(BinaryenModuleRef module, const char* name) { - return ((Module*)module)->getEvent(name); + return ((Module*)module)->getEventOrNull(name); } void BinaryenRemoveEvent(BinaryenModuleRef module, const char* name) { ((Module*)module)->removeEvent(name); @@ -3330,9 +3201,24 @@ ((Module*)module)->addExport(ret); return ret; } +BinaryenExportRef BinaryenGetExport(BinaryenModuleRef module, + const char* externalName) { + return ((Module*)module)->getExportOrNull(externalName); +} void BinaryenRemoveExport(BinaryenModuleRef module, const char* externalName) { ((Module*)module)->removeExport(externalName); } +BinaryenIndex BinaryenGetNumExports(BinaryenModuleRef module) { + return ((Module*)module)->exports.size(); +} +BinaryenExportRef BinaryenGetExportByIndex(BinaryenModuleRef module, + BinaryenIndex index) { + const auto& exports = ((Module*)module)->exports; + if (exports.size() <= index) { + Fatal() << "invalid export index."; + } + return exports[index].get(); +} // Function table. One per module @@ -3412,7 +3298,8 @@ wasm->addExport(memoryExport.release()); } for (BinaryenIndex i = 0; i < numSegments; i++) { - wasm->memory.segments.emplace_back(segmentPassive[i], + wasm->memory.segments.emplace_back(Name(), + segmentPassive[i], (Expression*)segmentOffsets[i], segments[i], segmentSizes[i]); @@ -3518,7 +3405,7 @@ } void BinaryenModulePrint(BinaryenModuleRef module) { - WasmPrinter::printModule((Module*)module); + std::cout << *(Module*)module; } void BinaryenModulePrintAsmjs(BinaryenModuleRef module) { @@ -3682,7 +3569,7 @@ // use a stringstream as an std::ostream. Extract the std::string // representation, and then store in the output. std::stringstream ss; - WasmPrinter::printModule((Module*)module, ss); + ss << *(Module*)module; const auto temp = ss.str(); const auto ctemp = temp.c_str(); @@ -3727,7 +3614,7 @@ char* BinaryenModuleAllocateAndWriteText(BinaryenModuleRef module) { std::stringstream ss; - WasmPrinter::printModule((Module*)module, ss); + ss << *(Module*)module; const std::string out = ss.str(); const int len = out.length() + 1; @@ -3822,7 +3709,7 @@ BinaryenModuleRef module) { PassRunner passRunner((Module*)module); passRunner.options = globalPassOptions; - passRunner.addDefaultOptimizationPasses(); + passRunner.addDefaultFunctionOptimizationPasses(); passRunner.runOnFunction((Function*)func); } void BinaryenFunctionRunPasses(BinaryenFunctionRef func, @@ -3948,17 +3835,6 @@ } const char* BinaryenExportGetValue(BinaryenExportRef export_) { return ((Export*)export_)->value.c_str(); -} -uint32_t BinaryenGetNumExports(BinaryenModuleRef module) { - return ((Module*)module)->exports.size(); -} -BinaryenExportRef BinaryenGetExportByIndex(BinaryenModuleRef module, - BinaryenIndex id) { - const auto& exports = ((Module*)module)->exports; - if (exports.size() <= id) { - Fatal() << "invalid export id."; - } - return exports[id].get(); } // diff --git a/binaryen/src/binaryen-c.h b/binaryen/src/binaryen-c.h --- a/binaryen/src/binaryen-c.h +++ b/binaryen/src/binaryen-c.h @@ -25,7 +25,7 @@ // graph (CFG) as input. // // The final part of the API contains miscellaneous utilities like -// debugging/tracing for the API itself. +// debugging for the API itself. // // --------------- // @@ -125,70 +125,12 @@ typedef uint32_t BinaryenExpressionId; BINARYEN_API BinaryenExpressionId BinaryenInvalidId(void); -BINARYEN_API BinaryenExpressionId BinaryenBlockId(void); -BINARYEN_API BinaryenExpressionId BinaryenIfId(void); -BINARYEN_API BinaryenExpressionId BinaryenLoopId(void); -BINARYEN_API BinaryenExpressionId BinaryenBreakId(void); -BINARYEN_API BinaryenExpressionId BinaryenSwitchId(void); -BINARYEN_API BinaryenExpressionId BinaryenCallId(void); -BINARYEN_API BinaryenExpressionId BinaryenCallIndirectId(void); -BINARYEN_API BinaryenExpressionId BinaryenLocalGetId(void); -BINARYEN_API BinaryenExpressionId BinaryenLocalSetId(void); -BINARYEN_API BinaryenExpressionId BinaryenGlobalGetId(void); -BINARYEN_API BinaryenExpressionId BinaryenGlobalSetId(void); -BINARYEN_API BinaryenExpressionId BinaryenLoadId(void); -BINARYEN_API BinaryenExpressionId BinaryenStoreId(void); -BINARYEN_API BinaryenExpressionId BinaryenConstId(void); -BINARYEN_API BinaryenExpressionId BinaryenUnaryId(void); -BINARYEN_API BinaryenExpressionId BinaryenBinaryId(void); -BINARYEN_API BinaryenExpressionId BinaryenSelectId(void); -BINARYEN_API BinaryenExpressionId BinaryenDropId(void); -BINARYEN_API BinaryenExpressionId BinaryenReturnId(void); -BINARYEN_API BinaryenExpressionId BinaryenMemorySizeId(void); -BINARYEN_API BinaryenExpressionId BinaryenMemoryGrowId(void); -BINARYEN_API BinaryenExpressionId BinaryenNopId(void); -BINARYEN_API BinaryenExpressionId BinaryenUnreachableId(void); -BINARYEN_API BinaryenExpressionId BinaryenAtomicCmpxchgId(void); -BINARYEN_API BinaryenExpressionId BinaryenAtomicRMWId(void); -BINARYEN_API BinaryenExpressionId BinaryenAtomicWaitId(void); -BINARYEN_API BinaryenExpressionId BinaryenAtomicNotifyId(void); -BINARYEN_API BinaryenExpressionId BinaryenAtomicFenceId(void); -BINARYEN_API BinaryenExpressionId BinaryenSIMDExtractId(void); -BINARYEN_API BinaryenExpressionId BinaryenSIMDReplaceId(void); -BINARYEN_API BinaryenExpressionId BinaryenSIMDShuffleId(void); -BINARYEN_API BinaryenExpressionId BinaryenSIMDTernaryId(void); -BINARYEN_API BinaryenExpressionId BinaryenSIMDShiftId(void); -BINARYEN_API BinaryenExpressionId BinaryenSIMDLoadId(void); -BINARYEN_API BinaryenExpressionId BinaryenMemoryInitId(void); -BINARYEN_API BinaryenExpressionId BinaryenDataDropId(void); -BINARYEN_API BinaryenExpressionId BinaryenMemoryCopyId(void); -BINARYEN_API BinaryenExpressionId BinaryenMemoryFillId(void); -BINARYEN_API BinaryenExpressionId BinaryenRefNullId(void); -BINARYEN_API BinaryenExpressionId BinaryenRefIsNullId(void); -BINARYEN_API BinaryenExpressionId BinaryenRefFuncId(void); -BINARYEN_API BinaryenExpressionId BinaryenRefEqId(void); -BINARYEN_API BinaryenExpressionId BinaryenTryId(void); -BINARYEN_API BinaryenExpressionId BinaryenThrowId(void); -BINARYEN_API BinaryenExpressionId BinaryenRethrowId(void); -BINARYEN_API BinaryenExpressionId BinaryenBrOnExnId(void); -BINARYEN_API BinaryenExpressionId BinaryenTupleMakeId(void); -BINARYEN_API BinaryenExpressionId BinaryenTupleExtractId(void); -BINARYEN_API BinaryenExpressionId BinaryenPopId(void); -BINARYEN_API BinaryenExpressionId BinaryenI31NewId(void); -BINARYEN_API BinaryenExpressionId BinaryenI31GetId(void); -BINARYEN_API BinaryenExpressionId BinaryenRefTestId(void); -BINARYEN_API BinaryenExpressionId BinaryenRefCastId(void); -BINARYEN_API BinaryenExpressionId BinaryenBrOnCastId(void); -BINARYEN_API BinaryenExpressionId BinaryenRttCanonId(void); -BINARYEN_API BinaryenExpressionId BinaryenRttSubId(void); -BINARYEN_API BinaryenExpressionId BinaryenStructNewId(void); -BINARYEN_API BinaryenExpressionId BinaryenStructGetId(void); -BINARYEN_API BinaryenExpressionId BinaryenStructSetId(void); -BINARYEN_API BinaryenExpressionId BinaryenArrayNewId(void); -BINARYEN_API BinaryenExpressionId BinaryenArrayGetId(void); -BINARYEN_API BinaryenExpressionId BinaryenArraySetId(void); -BINARYEN_API BinaryenExpressionId BinaryenArrayLenId(void); +#define DELEGATE(CLASS_TO_VISIT) \ + BINARYEN_API BinaryenExpressionId Binaryen##CLASS_TO_VISIT##Id(void); + +#include "wasm-delegations.h" + // External kinds (call to get the value of each; you can cache them) typedef uint32_t BinaryenExternalKind; @@ -484,6 +426,7 @@ BINARYEN_API BinaryenOp BinaryenXorVec128(void); BINARYEN_API BinaryenOp BinaryenAndNotVec128(void); BINARYEN_API BinaryenOp BinaryenBitselectVec128(void); +// TODO: Add i8x16.popcnt to C and JS APIs once merged to the proposal BINARYEN_API BinaryenOp BinaryenAbsVecI8x16(void); BINARYEN_API BinaryenOp BinaryenNegVecI8x16(void); BINARYEN_API BinaryenOp BinaryenAnyTrueVecI8x16(void); @@ -524,6 +467,8 @@ BINARYEN_API BinaryenOp BinaryenMaxSVecI16x8(void); BINARYEN_API BinaryenOp BinaryenMaxUVecI16x8(void); BINARYEN_API BinaryenOp BinaryenAvgrUVecI16x8(void); +// TODO: Add i16x8.q15mulr_sat_s to C and JS APIs once merged to the proposal +// TODO: Add extending multiplications to APIs once they are merged as well BINARYEN_API BinaryenOp BinaryenAbsVecI32x4(void); BINARYEN_API BinaryenOp BinaryenNegVecI32x4(void); BINARYEN_API BinaryenOp BinaryenAnyTrueVecI32x4(void); @@ -541,8 +486,6 @@ BINARYEN_API BinaryenOp BinaryenMaxUVecI32x4(void); BINARYEN_API BinaryenOp BinaryenDotSVecI16x8ToVecI32x4(void); BINARYEN_API BinaryenOp BinaryenNegVecI64x2(void); -BINARYEN_API BinaryenOp BinaryenAnyTrueVecI64x2(void); -BINARYEN_API BinaryenOp BinaryenAllTrueVecI64x2(void); BINARYEN_API BinaryenOp BinaryenShlVecI64x2(void); BINARYEN_API BinaryenOp BinaryenShrSVecI64x2(void); BINARYEN_API BinaryenOp BinaryenShrUVecI64x2(void); @@ -583,6 +526,7 @@ BINARYEN_API BinaryenOp BinaryenFloorVecF64x2(void); BINARYEN_API BinaryenOp BinaryenTruncVecF64x2(void); BINARYEN_API BinaryenOp BinaryenNearestVecF64x2(void); +// TODO: Add extending pairwise adds to C and JS APIs once merged BINARYEN_API BinaryenOp BinaryenTruncSatSVecF32x4ToVecI32x4(void); BINARYEN_API BinaryenOp BinaryenTruncSatUVecF32x4ToVecI32x4(void); BINARYEN_API BinaryenOp BinaryenTruncSatSVecF64x2ToVecI64x2(void); @@ -847,7 +791,8 @@ BINARYEN_API BinaryenExpressionRef BinaryenRefIsNull(BinaryenModuleRef module, BinaryenExpressionRef value); BINARYEN_API BinaryenExpressionRef BinaryenRefFunc(BinaryenModuleRef module, - const char* func); + const char* func, + BinaryenType type); BINARYEN_API BinaryenExpressionRef BinaryenRefEq(BinaryenModuleRef module, BinaryenExpressionRef left, BinaryenExpressionRef right); @@ -1459,47 +1404,47 @@ // AtomicWait -// Gets the pointer expression of an `atomic.wait` expression. +// Gets the pointer expression of an `memory.atomic.wait` expression. BINARYEN_API BinaryenExpressionRef BinaryenAtomicWaitGetPtr(BinaryenExpressionRef expr); -// Sets the pointer expression of an `atomic.wait` expression. +// Sets the pointer expression of an `memory.atomic.wait` expression. BINARYEN_API void BinaryenAtomicWaitSetPtr(BinaryenExpressionRef expr, BinaryenExpressionRef ptrExpr); -// Gets the expression representing the expected value of an `atomic.wait` -// expression. +// Gets the expression representing the expected value of an +// `memory.atomic.wait` expression. BINARYEN_API BinaryenExpressionRef BinaryenAtomicWaitGetExpected(BinaryenExpressionRef expr); -// Sets the expression representing the expected value of an `atomic.wait` -// expression. +// Sets the expression representing the expected value of an +// `memory.atomic.wait` expression. BINARYEN_API void BinaryenAtomicWaitSetExpected(BinaryenExpressionRef expr, BinaryenExpressionRef expectedExpr); -// Gets the timeout expression of an `atomic.wait` expression. +// Gets the timeout expression of an `memory.atomic.wait` expression. BINARYEN_API BinaryenExpressionRef BinaryenAtomicWaitGetTimeout(BinaryenExpressionRef expr); -// Sets the timeout expression of an `atomic.wait` expression. +// Sets the timeout expression of an `memory.atomic.wait` expression. BINARYEN_API void BinaryenAtomicWaitSetTimeout(BinaryenExpressionRef expr, BinaryenExpressionRef timeoutExpr); -// Gets the expected type of an `atomic.wait` expression. +// Gets the expected type of an `memory.atomic.wait` expression. BINARYEN_API BinaryenType BinaryenAtomicWaitGetExpectedType(BinaryenExpressionRef expr); -// Sets the expected type of an `atomic.wait` expression. +// Sets the expected type of an `memory.atomic.wait` expression. BINARYEN_API void BinaryenAtomicWaitSetExpectedType(BinaryenExpressionRef expr, BinaryenType expectedType); // AtomicNotify -// Gets the pointer expression of an `atomic.notify` expression. +// Gets the pointer expression of an `memory.atomic.notify` expression. BINARYEN_API BinaryenExpressionRef BinaryenAtomicNotifyGetPtr(BinaryenExpressionRef expr); -// Sets the pointer expression of an `atomic.notify` expression. +// Sets the pointer expression of an `memory.atomic.notify` expression. BINARYEN_API void BinaryenAtomicNotifySetPtr(BinaryenExpressionRef expr, BinaryenExpressionRef ptrExpr); -// Gets the notify count expression of an `atomic.notify` expression. +// Gets the notify count expression of an `memory.atomic.notify` expression. BINARYEN_API BinaryenExpressionRef BinaryenAtomicNotifyGetNotifyCount(BinaryenExpressionRef expr); -// Sets the notify count expression of an `atomic.notify` expression. +// Sets the notify count expression of an `memory.atomic.notify` expression. BINARYEN_API void BinaryenAtomicNotifySetNotifyCount(BinaryenExpressionRef expr, BinaryenExpressionRef notifyCountExpr); @@ -1926,7 +1871,8 @@ BinaryenType* varTypes, BinaryenIndex numVarTypes, BinaryenExpressionRef body); -// Gets a function reference by name. +// Gets a function reference by name. Returns NULL if the function does not +// exist. BINARYEN_API BinaryenFunctionRef BinaryenGetFunction(BinaryenModuleRef module, const char* name); // Removes a function by name. @@ -1934,10 +1880,10 @@ const char* name); // Gets the number of functions in the module. -BINARYEN_API uint32_t BinaryenGetNumFunctions(BinaryenModuleRef module); -// Get function pointer from its index. +BINARYEN_API BinaryenIndex BinaryenGetNumFunctions(BinaryenModuleRef module); +// Gets the function at the specified index. BINARYEN_API BinaryenFunctionRef -BinaryenGetFunctionByIndex(BinaryenModuleRef module, BinaryenIndex id); +BinaryenGetFunctionByIndex(BinaryenModuleRef module, BinaryenIndex index); // Imports @@ -1977,47 +1923,72 @@ WASM_DEPRECATED BinaryenExportRef BinaryenAddExport(BinaryenModuleRef module, const char* internalName, const char* externalName); +// Adds a function export to the module. BINARYEN_API BinaryenExportRef BinaryenAddFunctionExport( BinaryenModuleRef module, const char* internalName, const char* externalName); +// Adds a table export to the module. BINARYEN_API BinaryenExportRef BinaryenAddTableExport(BinaryenModuleRef module, const char* internalName, const char* externalName); +// Adds a memory export to the module. BINARYEN_API BinaryenExportRef BinaryenAddMemoryExport( BinaryenModuleRef module, const char* internalName, const char* externalName); +// Adds a global export to the module. BINARYEN_API BinaryenExportRef BinaryenAddGlobalExport( BinaryenModuleRef module, const char* internalName, const char* externalName); +// Adds an event export to the module. BINARYEN_API BinaryenExportRef BinaryenAddEventExport(BinaryenModuleRef module, const char* internalName, const char* externalName); +// Gets an export reference by external name. Returns NULL if the export does +// not exist. +BINARYEN_API BinaryenExportRef BinaryenGetExport(BinaryenModuleRef module, + const char* externalName); +// Removes an export by external name. BINARYEN_API void BinaryenRemoveExport(BinaryenModuleRef module, const char* externalName); +// Gets the number of exports in the module. +BINARYEN_API BinaryenIndex BinaryenGetNumExports(BinaryenModuleRef module); +// Gets the export at the specified index. +BINARYEN_API BinaryenExportRef +BinaryenGetExportByIndex(BinaryenModuleRef module, BinaryenIndex index); // Globals BINARYEN_REF(Global); +// Adds a global to the module. BINARYEN_API BinaryenGlobalRef BinaryenAddGlobal(BinaryenModuleRef module, const char* name, BinaryenType type, int8_t mutable_, BinaryenExpressionRef init); -// Gets a global reference by name. +// Gets a global reference by name. Returns NULL if the global does not exist. BINARYEN_API BinaryenGlobalRef BinaryenGetGlobal(BinaryenModuleRef module, const char* name); +// Removes a global by name. BINARYEN_API void BinaryenRemoveGlobal(BinaryenModuleRef module, const char* name); +// Gets the number of globals in the module. +BINARYEN_API BinaryenIndex BinaryenGetNumGlobals(BinaryenModuleRef module); +// Gets the global at the specified index. +BINARYEN_API BinaryenGlobalRef +BinaryenGetGlobalByIndex(BinaryenModuleRef module, BinaryenIndex index); // Events BINARYEN_REF(Event); +// Adds an event to the module. BINARYEN_API BinaryenEventRef BinaryenAddEvent(BinaryenModuleRef module, const char* name, uint32_t attribute, BinaryenType params, BinaryenType results); +// Gets an event reference by name. Returns NULL if the event does not exist. BINARYEN_API BinaryenEventRef BinaryenGetEvent(BinaryenModuleRef module, const char* name); +// Removes an event by name. BINARYEN_API void BinaryenRemoveEvent(BinaryenModuleRef module, const char* name); @@ -2385,11 +2356,6 @@ BINARYEN_API const char* BinaryenExportGetName(BinaryenExportRef export_); // Gets the internal name of the specified export. BINARYEN_API const char* BinaryenExportGetValue(BinaryenExportRef export_); -// Gets the number of exports in the module. -BINARYEN_API uint32_t BinaryenGetNumExports(BinaryenModuleRef module); -// Get export pointer from its index. -BINARYEN_API BinaryenExportRef -BinaryenGetExportByIndex(BinaryenModuleRef module, BinaryenIndex id); // // ========= Custom sections ========= @@ -2549,10 +2515,10 @@ // ========= Utilities ========= // -// Enable or disable coloring for the WASM printer +// Enable or disable coloring for the Wasm printer BINARYEN_API void BinaryenSetColorsEnabled(int enabled); -// Query whether color is enable for the WASM printer +// Query whether color is enable for the Wasm printer BINARYEN_API int BinaryenAreColorsEnabled(); #ifdef __cplusplus } // extern "C" diff --git a/binaryen/src/config.h b/binaryen/src/config.h --- a/binaryen/src/config.h +++ b/binaryen/src/config.h @@ -1,1 +1,1 @@ -#define PROJECT_VERSION "98" +#define PROJECT_VERSION "98 (version_99)" diff --git a/binaryen/src/dataflow/utils.h b/binaryen/src/dataflow/utils.h --- a/binaryen/src/dataflow/utils.h +++ b/binaryen/src/dataflow/utils.h @@ -26,7 +26,6 @@ #define wasm_dataflow_utils_h #include "dataflow/node.h" -#include "wasm-printing.h" #include "wasm.h" namespace wasm { @@ -47,7 +46,7 @@ break; case Node::Type::Expr: { o << "expr "; - WasmPrinter::printExpression(node->expr, o, true); + o << *node->expr << '\n'; break; } case Node::Type::Phi: diff --git a/binaryen/src/gen-s-parser.inc b/binaryen/src/gen-s-parser.inc --- a/binaryen/src/gen-s-parser.inc +++ b/binaryen/src/gen-s-parser.inc @@ -4,8 +4,8 @@ #ifdef INSTRUCTION_PARSER #undef INSTRUCTION_PARSER -char op[28] = {'\0'}; -strncpy(op, s[0]->c_str(), 27); +char op[30] = {'\0'}; +strncpy(op, s[0]->c_str(), 29); switch (op[0]) { case 'a': { switch (op[1]) { @@ -50,17 +50,9 @@ 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; - } - } + case 't': + if (strcmp(op, "atomic.fence") == 0) { return makeAtomicFence(s); } + goto parse_error; default: goto parse_error; } } @@ -107,9 +99,17 @@ 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; + case '_': { + switch (op[5]) { + case 'i': + if (strcmp(op, "call_indirect") == 0) { return makeCallIndirect(s, /*isReturn=*/false); } + goto parse_error; + case 'r': + if (strcmp(op, "call_ref") == 0) { return makeCallRef(s, /*isReturn=*/false); } + goto parse_error; + default: goto parse_error; + } + } default: goto parse_error; } } @@ -799,13 +799,56 @@ 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; + switch (op[9]) { + case 'a': { + switch (op[28]) { + case 's': + if (strcmp(op, "i16x8.extadd_pairwise_i8x16_s") == 0) { return makeUnary(s, UnaryOp::ExtAddPairwiseSVecI8x16ToI16x8); } + goto parse_error; + case 'u': + if (strcmp(op, "i16x8.extadd_pairwise_i8x16_u") == 0) { return makeUnary(s, UnaryOp::ExtAddPairwiseUVecI8x16ToI16x8); } + goto parse_error; + default: goto parse_error; + } + } + case 'm': { + switch (op[13]) { + case 'h': { + switch (op[24]) { + case 's': + if (strcmp(op, "i16x8.extmul_high_i8x16_s") == 0) { return makeBinary(s, BinaryOp::ExtMulHighSVecI16x8); } + goto parse_error; + case 'u': + if (strcmp(op, "i16x8.extmul_high_i8x16_u") == 0) { return makeBinary(s, BinaryOp::ExtMulHighUVecI16x8); } + goto parse_error; + default: goto parse_error; + } + } + case 'l': { + switch (op[23]) { + case 's': + if (strcmp(op, "i16x8.extmul_low_i8x16_s") == 0) { return makeBinary(s, BinaryOp::ExtMulLowSVecI16x8); } + goto parse_error; + case 'u': + if (strcmp(op, "i16x8.extmul_low_i8x16_u") == 0) { return makeBinary(s, BinaryOp::ExtMulLowUVecI16x8); } + goto parse_error; + default: goto parse_error; + } + } + default: goto parse_error; + } + } + case 'r': { + 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; } } @@ -934,6 +977,9 @@ default: goto parse_error; } } + case 'q': + if (strcmp(op, "i16x8.q15mulr_sat_s") == 0) { return makeBinary(s, BinaryOp::Q15MulrSatSVecI16x8); } + goto parse_error; case 'r': if (strcmp(op, "i16x8.replace_lane") == 0) { return makeSIMDReplace(s, SIMDReplaceOp::ReplaceLaneVecI16x8, 8); } goto parse_error; @@ -1189,9 +1235,6 @@ 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; } } @@ -1520,9 +1563,52 @@ 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; + case 'x': { + switch (op[9]) { + case 'a': { + switch (op[28]) { + case 's': + if (strcmp(op, "i32x4.extadd_pairwise_i16x8_s") == 0) { return makeUnary(s, UnaryOp::ExtAddPairwiseSVecI16x8ToI32x4); } + goto parse_error; + case 'u': + if (strcmp(op, "i32x4.extadd_pairwise_i16x8_u") == 0) { return makeUnary(s, UnaryOp::ExtAddPairwiseUVecI16x8ToI32x4); } + goto parse_error; + default: goto parse_error; + } + } + case 'm': { + switch (op[13]) { + case 'h': { + switch (op[24]) { + case 's': + if (strcmp(op, "i32x4.extmul_high_i16x8_s") == 0) { return makeBinary(s, BinaryOp::ExtMulHighSVecI32x4); } + goto parse_error; + case 'u': + if (strcmp(op, "i32x4.extmul_high_i16x8_u") == 0) { return makeBinary(s, BinaryOp::ExtMulHighUVecI32x4); } + goto parse_error; + default: goto parse_error; + } + } + case 'l': { + switch (op[23]) { + case 's': + if (strcmp(op, "i32x4.extmul_low_i16x8_s") == 0) { return makeBinary(s, BinaryOp::ExtMulLowSVecI32x4); } + goto parse_error; + case 'u': + if (strcmp(op, "i32x4.extmul_low_i16x8_u") == 0) { return makeBinary(s, BinaryOp::ExtMulLowUVecI32x4); } + goto parse_error; + default: goto parse_error; + } + } + default: goto parse_error; + } + } + case 'r': + if (strcmp(op, "i32x4.extract_lane") == 0) { return makeSIMDExtract(s, SIMDExtractOp::ExtractLaneVecI32x4, 4); } + goto parse_error; + default: goto parse_error; + } + } default: goto parse_error; } } @@ -1909,9 +1995,6 @@ 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; } } @@ -2237,23 +2320,55 @@ } case 'x': { switch (op[6]) { - case 'a': { + case 'a': + if (strcmp(op, "i64x2.add") == 0) { return makeBinary(s, BinaryOp::AddVecI64x2); } + goto parse_error; + case 'b': + if (strcmp(op, "i64x2.bitmask") == 0) { return makeUnary(s, UnaryOp::BitmaskVecI64x2); } + goto parse_error; + case 'e': { 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); } + case 'q': + if (strcmp(op, "i64x2.eq") == 0) { return makeBinary(s, BinaryOp::EqVecI64x2); } goto parse_error; + case 'x': { + switch (op[9]) { + case 'm': { + switch (op[13]) { + case 'h': { + switch (op[24]) { + case 's': + if (strcmp(op, "i64x2.extmul_high_i32x4_s") == 0) { return makeBinary(s, BinaryOp::ExtMulHighSVecI64x2); } + goto parse_error; + case 'u': + if (strcmp(op, "i64x2.extmul_high_i32x4_u") == 0) { return makeBinary(s, BinaryOp::ExtMulHighUVecI64x2); } + goto parse_error; + default: goto parse_error; + } + } + case 'l': { + switch (op[23]) { + case 's': + if (strcmp(op, "i64x2.extmul_low_i32x4_s") == 0) { return makeBinary(s, BinaryOp::ExtMulLowSVecI64x2); } + goto parse_error; + case 'u': + if (strcmp(op, "i64x2.extmul_low_i32x4_u") == 0) { return makeBinary(s, BinaryOp::ExtMulLowUVecI64x2); } + goto parse_error; + default: goto parse_error; + } + } + default: goto parse_error; + } + } + case 'r': + if (strcmp(op, "i64x2.extract_lane") == 0) { return makeSIMDExtract(s, SIMDExtractOp::ExtractLaneVecI64x2, 2); } + goto parse_error; + default: 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': @@ -2315,6 +2430,33 @@ default: goto parse_error; } } + case 'w': { + switch (op[12]) { + case 'h': { + switch (op[23]) { + case 's': + if (strcmp(op, "i64x2.widen_high_i32x4_s") == 0) { return makeUnary(s, UnaryOp::WidenHighSVecI32x4ToVecI64x2); } + goto parse_error; + case 'u': + if (strcmp(op, "i64x2.widen_high_i32x4_u") == 0) { return makeUnary(s, UnaryOp::WidenHighUVecI32x4ToVecI64x2); } + goto parse_error; + default: goto parse_error; + } + } + case 'l': { + switch (op[22]) { + case 's': + if (strcmp(op, "i64x2.widen_low_i32x4_s") == 0) { return makeUnary(s, UnaryOp::WidenLowSVecI32x4ToVecI64x2); } + goto parse_error; + case 'u': + if (strcmp(op, "i64x2.widen_low_i32x4_u") == 0) { return makeUnary(s, UnaryOp::WidenLowUVecI32x4ToVecI64x2); } + goto parse_error; + default: goto parse_error; + } + } + default: goto parse_error; + } + } default: goto parse_error; } } @@ -2492,6 +2634,9 @@ default: goto parse_error; } } + case 'p': + if (strcmp(op, "i8x16.popcnt") == 0) { return makeUnary(s, UnaryOp::PopcntVecI8x16); } + goto parse_error; case 'r': if (strcmp(op, "i8x16.replace_lane") == 0) { return makeSIMDReplace(s, SIMDReplaceOp::ReplaceLaneVecI8x16, 16); } goto parse_error; @@ -2574,6 +2719,25 @@ } case 'm': { switch (op[7]) { + case 'a': { + switch (op[14]) { + case 'n': + if (strcmp(op, "memory.atomic.notify") == 0) { return makeAtomicNotify(s); } + goto parse_error; + case 'w': { + switch (op[18]) { + case '3': + if (strcmp(op, "memory.atomic.wait32") == 0) { return makeAtomicWait(s, Type::i32); } + goto parse_error; + case '6': + if (strcmp(op, "memory.atomic.wait64") == 0) { return makeAtomicWait(s, Type::i64); } + goto parse_error; + default: goto parse_error; + } + } + default: goto parse_error; + } + } case 'c': if (strcmp(op, "memory.copy") == 0) { return makeMemoryCopy(s); } goto parse_error; @@ -2595,9 +2759,25 @@ 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 'p': { + switch (op[1]) { + case 'o': + if (strcmp(op, "pop") == 0) { return makePop(s); } + goto parse_error; + case 'r': { + switch (op[9]) { + case 'n': + if (strcmp(op, "prefetch.nt") == 0) { return makePrefetch(s, PrefetchOp::PrefetchNontemporal); } + goto parse_error; + case 't': + if (strcmp(op, "prefetch.t") == 0) { return makePrefetch(s, PrefetchOp::PrefetchTemporal); } + goto parse_error; + default: goto parse_error; + } + } + default: goto parse_error; + } + } case 'r': { switch (op[1]) { case 'e': { @@ -2640,9 +2820,17 @@ 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; + case '_': { + switch (op[12]) { + case 'i': + if (strcmp(op, "return_call_indirect") == 0) { return makeCallIndirect(s, /*isReturn=*/true); } + goto parse_error; + case 'r': + if (strcmp(op, "return_call_ref") == 0) { return makeCallRef(s, /*isReturn=*/true); } + goto parse_error; + default: goto parse_error; + } + } default: goto parse_error; } } @@ -2776,11 +2964,33 @@ 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); } + case '1': + if (strcmp(op, "v128.load16_lane") == 0) { return makeSIMDLoadStoreLane(s, LoadLaneVec16x8); } goto parse_error; - case '6': - if (strcmp(op, "v128.load64_zero") == 0) { return makeSIMDLoad(s, SIMDLoadOp::Load64Zero); } + case '3': { + switch (op[12]) { + case 'l': + if (strcmp(op, "v128.load32_lane") == 0) { return makeSIMDLoadStoreLane(s, LoadLaneVec32x4); } + goto parse_error; + case 'z': + if (strcmp(op, "v128.load32_zero") == 0) { return makeSIMDLoad(s, SIMDLoadOp::Load32Zero); } + goto parse_error; + default: goto parse_error; + } + } + case '6': { + switch (op[12]) { + case 'l': + if (strcmp(op, "v128.load64_lane") == 0) { return makeSIMDLoadStoreLane(s, LoadLaneVec64x2); } + goto parse_error; + case 'z': + if (strcmp(op, "v128.load64_zero") == 0) { return makeSIMDLoad(s, SIMDLoadOp::Load64Zero); } + goto parse_error; + default: goto parse_error; + } + } + case '8': + if (strcmp(op, "v128.load8_lane") == 0) { return makeSIMDLoadStoreLane(s, LoadLaneVec8x16); } goto parse_error; default: goto parse_error; } @@ -2791,27 +3001,68 @@ 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 's': { + switch (op[10]) { + case '\0': + if (strcmp(op, "v128.store") == 0) { return makeStore(s, Type::v128, /*isAtomic=*/false); } + goto parse_error; + case '1': + if (strcmp(op, "v128.store16_lane") == 0) { return makeSIMDLoadStoreLane(s, StoreLaneVec16x8); } + goto parse_error; + case '3': + if (strcmp(op, "v128.store32_lane") == 0) { return makeSIMDLoadStoreLane(s, StoreLaneVec32x4); } + goto parse_error; + case '6': + if (strcmp(op, "v128.store64_lane") == 0) { return makeSIMDLoadStoreLane(s, StoreLaneVec64x2); } + goto parse_error; + case '8': + if (strcmp(op, "v128.store8_lane") == 0) { return makeSIMDLoadStoreLane(s, StoreLaneVec8x16); } + goto parse_error; + default: 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); } + case '6': { + switch (op[6]) { + case 'l': + if (strcmp(op, "v16x8.load_splat") == 0) { return makeSIMDLoad(s, SIMDLoadOp::LoadSplatVec16x8); } + goto parse_error; + case 's': + if (strcmp(op, "v16x8.signselect") == 0) { return makeSIMDTernary(s, SIMDTernaryOp::SignSelectVec16x8); } + goto parse_error; + default: goto parse_error; + } + } + default: goto parse_error; + } + } + case '3': { + switch (op[6]) { + case 'l': + if (strcmp(op, "v32x4.load_splat") == 0) { return makeSIMDLoad(s, SIMDLoadOp::LoadSplatVec32x4); } goto parse_error; + case 's': + if (strcmp(op, "v32x4.signselect") == 0) { return makeSIMDTernary(s, SIMDTernaryOp::SignSelectVec32x4); } + 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 '6': { + switch (op[6]) { + case 'l': + if (strcmp(op, "v64x2.load_splat") == 0) { return makeSIMDLoad(s, SIMDLoadOp::LoadSplatVec64x2); } + goto parse_error; + case 's': + if (strcmp(op, "v64x2.signselect") == 0) { return makeSIMDTernary(s, SIMDTernaryOp::SignSelectVec64x2); } + goto parse_error; + default: goto parse_error; + } + } case '8': { switch (op[6]) { case 'l': @@ -2821,6 +3072,9 @@ switch (op[7]) { case 'h': if (strcmp(op, "v8x16.shuffle") == 0) { return makeSIMDShuffle(s); } + goto parse_error; + case 'i': + if (strcmp(op, "v8x16.signselect") == 0) { return makeSIMDTernary(s, SIMDTernaryOp::SignSelectVec8x16); } goto parse_error; case 'w': if (strcmp(op, "v8x16.swizzle") == 0) { return makeBinary(s, BinaryOp::SwizzleVec8x16); } diff --git a/binaryen/src/ir/CMakeLists.txt b/binaryen/src/ir/CMakeLists.txt --- a/binaryen/src/ir/CMakeLists.txt +++ b/binaryen/src/ir/CMakeLists.txt @@ -5,6 +5,7 @@ LocalGraph.cpp ReFinalize.cpp stack-utils.cpp + module-splitting.cpp ${ir_HEADERS} ) add_library(ir OBJECT ${ir_SOURCES}) diff --git a/binaryen/src/ir/ExpressionAnalyzer.cpp b/binaryen/src/ir/ExpressionAnalyzer.cpp --- a/binaryen/src/ir/ExpressionAnalyzer.cpp +++ b/binaryen/src/ir/ExpressionAnalyzer.cpp @@ -96,186 +96,6 @@ 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) { @@ -285,80 +105,6 @@ 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; @@ -371,8 +117,6 @@ } 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(); @@ -390,45 +134,16 @@ if (!left) { continue; } + // There are actual expressions to compare here. Start with the custom + // comparer function that was provided. if (comparer(left, right)) { - continue; // comparison hook, before all the rest + continue; } - // continue with normal structural comparison - if (left->_id != right->_id) { + if (left->type != right->type) { 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) { + // Do the actual comparison, updating the names and stacks accordingly. + if (!compareNodes(left, right)) { return false; } } @@ -437,6 +152,97 @@ } return true; } + + bool compareNodes(Expression* left, Expression* right) { + if (left->_id != right->_id) { + return false; + } + +#define DELEGATE_ID left->_id + +// Create cast versions of it for later operations. +#define DELEGATE_START(id) \ + auto* castLeft = left->cast(); \ + WASM_UNUSED(castLeft); \ + auto* castRight = right->cast(); \ + WASM_UNUSED(castRight); + +// Handle each type of field, comparing it appropriately. +#define DELEGATE_FIELD_CHILD(id, name) \ + leftStack.push_back(castLeft->name); \ + rightStack.push_back(castRight->name); + +#define DELEGATE_FIELD_CHILD_VECTOR(id, name) \ + if (castLeft->name.size() != castRight->name.size()) { \ + return false; \ + } \ + for (auto* child : castLeft->name) { \ + leftStack.push_back(child); \ + } \ + for (auto* child : castRight->name) { \ + rightStack.push_back(child); \ + } + +#define COMPARE_FIELD(name) \ + if (castLeft->name != castRight->name) { \ + return false; \ + } + +#define DELEGATE_FIELD_INT(id, name) COMPARE_FIELD(name) +#define DELEGATE_FIELD_LITERAL(id, name) COMPARE_FIELD(name) +#define DELEGATE_FIELD_NAME(id, name) COMPARE_FIELD(name) +#define DELEGATE_FIELD_SIGNATURE(id, name) COMPARE_FIELD(name) +#define DELEGATE_FIELD_TYPE(id, name) COMPARE_FIELD(name) +#define DELEGATE_FIELD_ADDRESS(id, name) COMPARE_FIELD(name) + +#define COMPARE_LIST(name) \ + if (castLeft->name.size() != castRight->name.size()) { \ + return false; \ + } \ + for (Index i = 0; i < castLeft->name.size(); i++) { \ + if (castLeft->name[i] != castRight->name[i]) { \ + return false; \ + } \ + } + +#define DELEGATE_FIELD_INT_ARRAY(id, name) COMPARE_LIST(name) + +#define DELEGATE_FIELD_SCOPE_NAME_DEF(id, name) \ + if (castLeft->name.is() != castRight->name.is()) { \ + return false; \ + } \ + rightNames[castLeft->name] = castRight->name; + +#define DELEGATE_FIELD_SCOPE_NAME_USE(id, name) \ + if (!compareNames(castLeft->name, castRight->name)) { \ + return false; \ + } + +#define DELEGATE_FIELD_SCOPE_NAME_USE_VECTOR(id, name) \ + if (castLeft->name.size() != castRight->name.size()) { \ + return false; \ + } \ + for (Index i = 0; i < castLeft->name.size(); i++) { \ + if (!compareNames(castLeft->name[i], castRight->name[i])) { \ + return false; \ + } \ + } + +#include "wasm-delegations-fields.h" + + return true; + } + + bool compareNames(Name left, Name right) { + auto iter = rightNames.find(left); + // 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 != rightNames.end()) { + left = iter->second; + } + return left == right; + } }; return Comparer().compare(left, right, comparer); @@ -452,12 +258,6 @@ std::map internalNames; ExpressionStack stack; - void noteScopeName(Name curr) { - if (curr.is()) { - internalNames[curr] = internalCounter++; - } - } - Hasher(Expression* curr) { stack.push_back(curr); @@ -465,6 +265,9 @@ curr = stack.back(); stack.pop_back(); if (!curr) { + // This was an optional child that was not present. Hash a 0 to + // represent that. + rehash(digest, 0); continue; } rehash(digest, curr->_id); @@ -477,27 +280,51 @@ // 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); + // Hash the contents of the expression. + hashExpression(curr); } } + void hashExpression(Expression* curr) { + +#define DELEGATE_ID curr->_id + +// Create cast versions of it for later operations. +#define DELEGATE_START(id) \ + auto* cast = curr->cast(); \ + WASM_UNUSED(cast); + +// Handle each type of field, comparing it appropriately. +#define DELEGATE_GET_FIELD(id, name) cast->name + +#define DELEGATE_FIELD_CHILD(id, name) stack.push_back(cast->name); + +#define HASH_FIELD(name) rehash(digest, cast->name); + +#define DELEGATE_FIELD_INT(id, name) HASH_FIELD(name) +#define DELEGATE_FIELD_LITERAL(id, name) HASH_FIELD(name) +#define DELEGATE_FIELD_SIGNATURE(id, name) HASH_FIELD(name) + +#define DELEGATE_FIELD_NAME(id, name) visitNonScopeName(cast->name) +#define DELEGATE_FIELD_TYPE(id, name) visitType(cast->name); +#define DELEGATE_FIELD_ADDRESS(id, name) visitAddress(cast->name); + +// Note that we only note the scope name, but do not also visit it. That means +// that (block $x) and (block) get the same hash. In other words, we only change +// the hash based on uses of scope names, that is when there is a noticeable +// difference in break targets. +#define DELEGATE_FIELD_SCOPE_NAME_DEF(id, name) noteScopeName(cast->name); + +#define DELEGATE_FIELD_SCOPE_NAME_USE(id, name) visitScopeName(cast->name); + +#include "wasm-delegations-fields.h" + } + + void noteScopeName(Name curr) { + if (curr.is()) { + internalNames[curr] = internalCounter++; + } + } void visitScopeName(Name curr) { // Names are relative, we give the same hash for // (block $x (br $x)) @@ -508,14 +335,7 @@ 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); } }; diff --git a/binaryen/src/ir/ExpressionManipulator.cpp b/binaryen/src/ir/ExpressionManipulator.cpp --- a/binaryen/src/ir/ExpressionManipulator.cpp +++ b/binaryen/src/ir/ExpressionManipulator.cpp @@ -23,298 +23,92 @@ Expression* flexibleCopy(Expression* original, Module& wasm, CustomCopier custom) { - struct Copier : public OverriddenVisitor { - Module& wasm; - CustomCopier custom; + // Perform the copy using a stack of tasks (avoiding recusion). + struct CopyTask { + // The thing to copy. + Expression* original; + // The location of the pointer to write the copy to. + Expression** destPointer; + }; + std::vector tasks; + Expression* ret; + tasks.push_back({original, &ret}); + while (!tasks.empty()) { + auto task = tasks.back(); + tasks.pop_back(); + // If the custom copier handled this one, we have nothing to do. + auto* copy = custom(task.original); + if (copy) { + *task.destPointer = copy; + continue; + } + // If the original is a null, just copy that. (This can happen for an + // optional child.) + auto* original = task.original; + if (original == nullptr) { + *task.destPointer = nullptr; + continue; + } + // Allocate a new copy, and copy the fields. - Builder builder; +#define DELEGATE_ID original->_id - Copier(Module& wasm, CustomCopier custom) - : wasm(wasm), custom(custom), builder(wasm) {} +// Allocate a new expression of the right type, and create cast versions of it +// for later operations. +#define DELEGATE_START(id) \ + copy = wasm.allocator.alloc(); \ + auto* castOriginal = original->cast(); \ + WASM_UNUSED(castOriginal); \ + auto* castCopy = copy->cast(); \ + WASM_UNUSED(castCopy); - Expression* copy(Expression* curr) { - if (!curr) { - return nullptr; - } - auto* ret = custom(curr); - if (ret) { - return ret; - } - return OverriddenVisitor::visit(curr); - } +// Handle each type of field, copying it appropriately. +#define DELEGATE_FIELD_CHILD(id, name) \ + tasks.push_back({castOriginal->name, &castCopy->name}); - 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"); - } - }; +#define DELEGATE_FIELD_CHILD_VECTOR(id, name) \ + castCopy->name.resize(castOriginal->name.size()); \ + for (Index i = 0; i < castOriginal->name.size(); i++) { \ + tasks.push_back({castOriginal->name[i], &castCopy->name[i]}); \ + } - Copier copier(wasm, custom); - return copier.copy(original); +#define COPY_FIELD(name) castCopy->name = castOriginal->name; + +#define DELEGATE_FIELD_INT(id, name) COPY_FIELD(name) +#define DELEGATE_FIELD_LITERAL(id, name) COPY_FIELD(name) +#define DELEGATE_FIELD_NAME(id, name) COPY_FIELD(name) +#define DELEGATE_FIELD_SCOPE_NAME_DEF(id, name) COPY_FIELD(name) +#define DELEGATE_FIELD_SCOPE_NAME_USE(id, name) COPY_FIELD(name) +#define DELEGATE_FIELD_SIGNATURE(id, name) COPY_FIELD(name) +#define DELEGATE_FIELD_TYPE(id, name) COPY_FIELD(name) +#define DELEGATE_FIELD_ADDRESS(id, name) COPY_FIELD(name) + +#define COPY_FIELD_LIST(name) \ + for (Index i = 0; i < castOriginal->name.size(); i++) { \ + castCopy->name[i] = castOriginal->name[i]; \ + } + +#define COPY_VECTOR(name) \ + castCopy->name.resize(castOriginal->name.size()); \ + COPY_FIELD_LIST(name) + +#define COPY_ARRAY(name) \ + assert(castCopy->name.size() == castOriginal->name.size()); \ + COPY_FIELD_LIST(name) + +#define DELEGATE_FIELD_SCOPE_NAME_USE_VECTOR(id, name) COPY_VECTOR(name) + +#define DELEGATE_FIELD_INT_ARRAY(id, name) COPY_ARRAY(name) + +#include "wasm-delegations-fields.h" + + // The type can be simply copied. + copy->type = original->type; + + // Write the copy to where it should be referred to. + *task.destPointer = copy; + } + return ret; } // Splice an item into the middle of a block's list diff --git a/binaryen/src/ir/LocalGraph.cpp b/binaryen/src/ir/LocalGraph.cpp --- a/binaryen/src/ir/LocalGraph.cpp +++ b/binaryen/src/ir/LocalGraph.cpp @@ -20,7 +20,6 @@ #include #include #include -#include namespace wasm { diff --git a/binaryen/src/ir/ReFinalize.cpp b/binaryen/src/ir/ReFinalize.cpp --- a/binaryen/src/ir/ReFinalize.cpp +++ b/binaryen/src/ir/ReFinalize.cpp @@ -109,6 +109,10 @@ void ReFinalize::visitSIMDTernary(SIMDTernary* curr) { curr->finalize(); } void ReFinalize::visitSIMDShift(SIMDShift* curr) { curr->finalize(); } void ReFinalize::visitSIMDLoad(SIMDLoad* curr) { curr->finalize(); } +void ReFinalize::visitSIMDLoadStoreLane(SIMDLoadStoreLane* curr) { + curr->finalize(); +} +void ReFinalize::visitPrefetch(Prefetch* curr) { curr->finalize(); } void ReFinalize::visitMemoryInit(MemoryInit* curr) { curr->finalize(); } void ReFinalize::visitDataDrop(DataDrop* curr) { curr->finalize(); } void ReFinalize::visitMemoryCopy(MemoryCopy* curr) { curr->finalize(); } @@ -123,7 +127,11 @@ 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::visitRefFunc(RefFunc* curr) { + // TODO: should we look up the function and update the type from there? This + // could handle a change to the function's type, but is also not really what + // this class has been meant to do. +} void ReFinalize::visitRefEq(RefEq* curr) { curr->finalize(); } void ReFinalize::visitTry(Try* curr) { curr->finalize(); } void ReFinalize::visitThrow(Throw* curr) { curr->finalize(); } @@ -143,11 +151,16 @@ void ReFinalize::visitTupleExtract(TupleExtract* curr) { curr->finalize(); } void ReFinalize::visitI31New(I31New* curr) { curr->finalize(); } void ReFinalize::visitI31Get(I31Get* curr) { curr->finalize(); } +void ReFinalize::visitCallRef(CallRef* 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"); + if (curr->type == Type::unreachable) { + replaceUntaken(curr->ref, nullptr); + } else { + updateBreakValueType(curr->name, curr->getCastType()); + } } void ReFinalize::visitRttCanon(RttCanon* curr) { curr->finalize(); } void ReFinalize::visitRttSub(RttSub* curr) { curr->finalize(); } diff --git a/binaryen/src/ir/abstract.h b/binaryen/src/ir/abstract.h --- a/binaryen/src/ir/abstract.h +++ b/binaryen/src/ir/abstract.h @@ -27,6 +27,7 @@ enum Op { // Unary + Abs, Neg, // Binary Add, @@ -91,6 +92,8 @@ } case Type::f32: { switch (op) { + case Abs: + return AbsFloat32; case Neg: return NegFloat32; default: @@ -100,6 +103,8 @@ } case Type::f64: { switch (op) { + case Abs: + return AbsFloat64; case Neg: return NegFloat64; default: diff --git a/binaryen/src/ir/branch-utils.h b/binaryen/src/ir/branch-utils.h --- a/binaryen/src/ir/branch-utils.h +++ b/binaryen/src/ir/branch-utils.h @@ -28,111 +28,127 @@ // 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(Expression* expr) { + // If any child is unreachable, the branch is not taken. Note that expr itself + // may be unreachable regardless (as in the case of a simple Break with no + // condition, which is still taken). + for (auto child : ChildIterator(expr)) { + if (child->type == Type::unreachable) { + return false; + } + } + return true; } -inline bool isBranchReachable(Switch* sw) { - return !(sw->value && sw->value->type == Type::unreachable) && - sw->condition->type != Type::unreachable; -} +// Perform a generic operation on uses of scope names (branch targets) in an +// expression. The provided function receives a Name& which it can modify if it +// needs to. +template void operateOnScopeNameUses(Expression* expr, T func) { +#define DELEGATE_ID expr->_id -inline bool isBranchReachable(BrOnExn* br) { - return br->exnref->type != Type::unreachable; +#define DELEGATE_START(id) \ + auto* cast = expr->cast(); \ + WASM_UNUSED(cast); + +#define DELEGATE_GET_FIELD(id, name) cast->name + +#define DELEGATE_FIELD_SCOPE_NAME_USE(id, name) func(cast->name); + +#define DELEGATE_FIELD_CHILD(id, name) +#define DELEGATE_FIELD_INT(id, name) +#define DELEGATE_FIELD_LITERAL(id, name) +#define DELEGATE_FIELD_NAME(id, name) +#define DELEGATE_FIELD_SCOPE_NAME_DEF(id, name) +#define DELEGATE_FIELD_SIGNATURE(id, name) +#define DELEGATE_FIELD_TYPE(id, name) +#define DELEGATE_FIELD_ADDRESS(id, name) +#define DELEGATE_FIELD_CHILD_VECTOR(id, name) +#define DELEGATE_FIELD_INT_ARRAY(id, name) + +#include "wasm-delegations-fields.h" } -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"); +// Similar to operateOnScopeNameUses, but also passes in the type that is sent +// if the branch is taken. The type is none if there is no value. +template +void operateOnScopeNameUsesAndSentTypes(Expression* expr, T func) { + operateOnScopeNameUses(expr, [&](Name& name) { + // There isn't a delegate mechanism for getting a sent value, so do a direct + // if-else chain. This will need to be updated with new br variants. + if (auto* br = expr->dynCast()) { + func(name, br->value ? br->value->type : Type::none); + } else if (auto* sw = expr->dynCast()) { + func(name, sw->value ? sw->value->type : Type::none); + } else if (auto* br = expr->dynCast()) { + func(name, br->sent); + } else if (auto* br = expr->dynCast()) { + func(name, br->getCastType()); + } else { + WASM_UNREACHABLE("bad br type"); + } + }); } -using NameSet = std::set; +// Perform a generic operation on definitions of scope names in an expression. +// The provided function receives a Name& which it can modify if it needs to. +template void operateOnScopeNameDefs(Expression* expr, T func) { +#define DELEGATE_ID expr->_id -inline NameSet getUniqueTargets(Break* br) { return {br->name}; } +#define DELEGATE_START(id) \ + auto* cast = expr->cast(); \ + WASM_UNUSED(cast); -inline NameSet getUniqueTargets(Switch* sw) { - NameSet ret; - for (auto target : sw->targets) { - ret.insert(target); - } - ret.insert(sw->default_); - return ret; +#define DELEGATE_FIELD_SCOPE_NAME_DEF(id, name) func(cast->name) + +#define DELEGATE_FIELD_CHILD(id, name) +#define DELEGATE_FIELD_INT(id, name) +#define DELEGATE_FIELD_LITERAL(id, name) +#define DELEGATE_FIELD_NAME(id, name) +#define DELEGATE_FIELD_SIGNATURE(id, name) +#define DELEGATE_FIELD_TYPE(id, name) +#define DELEGATE_FIELD_ADDRESS(id, name) +#define DELEGATE_FIELD_CHILD_VECTOR(id, name) +#define DELEGATE_FIELD_INT_ARRAY(id, name) +#define DELEGATE_FIELD_SCOPE_NAME_USE(id, name) +#define DELEGATE_FIELD_SCOPE_NAME_USE_VECTOR(id, name) + +#include "wasm-delegations-fields.h" } -inline NameSet getUniqueTargets(BrOnExn* br) { return {br->name}; } +using NameSet = std::set; 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 {}; + NameSet ret; + operateOnScopeNameUses(expr, [&](Name& name) { ret.insert(name); }); + return ret; } + // 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; + operateOnScopeNameUses(branch, [&](Name& name) { + if (name == from) { + 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 +// Returns the set of targets to which we branch that are +// outside of an expression. inline NameSet getExitingBranches(Expression* ast) { - struct Scanner : public PostWalker { + 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); - } + void visitExpression(Expression* curr) { + operateOnScopeNameDefs(curr, [&](Name& name) { + if (name.is()) { + targets.erase(name); + } + }); + operateOnScopeNameUses(curr, [&](Name& name) { targets.insert(name); }); } }; Scanner scanner; @@ -144,18 +160,16 @@ // returns the list of all branch targets in a node inline NameSet getBranchTargets(Expression* ast) { - struct Scanner : public PostWalker { + 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); - } + void visitExpression(Expression* curr) { + operateOnScopeNameDefs(curr, [&](Name& name) { + if (name.is()) { + targets.insert(name); + } + }); } }; Scanner scanner; @@ -166,52 +180,33 @@ // 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 { +struct BranchSeeker + : public PostWalker> { Name target; Index found = 0; - Type valueType; + // None indicates no value is sent. + Type valueType = Type::none; BranchSeeker(Name target) : target(target) {} - void noteFound(Expression* value) { - noteFound(value ? value->type : Type::none); - } - - void noteFound(Type type) { + void noteFound(Type newType) { 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); + if (newType != Type::none) { + if (found == 1) { + valueType = newType; + } else { + valueType = Type::getLeastUpperBound(valueType, newType); + } } } - void visitSwitch(Switch* curr) { - // check the switch - for (auto name : curr->targets) { + void visitExpression(Expression* curr) { + operateOnScopeNameUsesAndSentTypes(curr, [&](Name& name, Type type) { if (name == target) { - noteFound(curr->value); + noteFound(type); } - } - 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) { diff --git a/binaryen/src/ir/cost.h b/binaryen/src/ir/cost.h --- a/binaryen/src/ir/cost.h +++ b/binaryen/src/ir/cost.h @@ -24,7 +24,7 @@ // Measure the execution cost of an AST. Very handwave-ey -struct CostAnalyzer : public Visitor { +struct CostAnalyzer : public OverriddenVisitor { CostAnalyzer(Expression* ast) { cost = visit(ast); } Index cost; @@ -65,18 +65,38 @@ } return ret; } + Index visitCallRef(CallRef* curr) { + Index ret = 5 + 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 visitLocalSet(LocalSet* curr) { return 1 + visit(curr->value); } Index visitGlobalGet(GlobalGet* curr) { return 1; } - Index visitGlobalSet(GlobalSet* curr) { return 2; } + Index visitGlobalSet(GlobalSet* curr) { return 2 + visit(curr->value); } 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 visitAtomicRMW(AtomicRMW* curr) { + return 100 + visit(curr->ptr) + visit(curr->value); + } + Index visitAtomicCmpxchg(AtomicCmpxchg* curr) { + return 100 + visit(curr->ptr) + visit(curr->expected) + + visit(curr->replacement); + } + Index visitAtomicWait(AtomicWait* curr) { + return 100 + visit(curr->ptr) + visit(curr->expected) + + visit(curr->timeout); + } + Index visitAtomicNotify(AtomicNotify* curr) { + return 100 + visit(curr->ptr) + visit(curr->notifyCount); + } + Index visitAtomicFence(AtomicFence* curr) { return 100; } Index visitConst(Const* curr) { return 1; } Index visitUnary(Unary* curr) { Index ret = 0; @@ -157,6 +177,7 @@ case AnyTrueVecI8x16: case AllTrueVecI8x16: case BitmaskVecI8x16: + case PopcntVecI8x16: case AbsVecI16x8: case NegVecI16x8: case AnyTrueVecI16x8: @@ -168,8 +189,7 @@ case AllTrueVecI32x4: case BitmaskVecI32x4: case NegVecI64x2: - case AnyTrueVecI64x2: - case AllTrueVecI64x2: + case BitmaskVecI64x2: case AbsVecF32x4: case NegVecF32x4: case SqrtVecF32x4: @@ -184,6 +204,10 @@ case FloorVecF64x2: case TruncVecF64x2: case NearestVecF64x2: + case ExtAddPairwiseSVecI8x16ToI16x8: + case ExtAddPairwiseUVecI8x16ToI16x8: + case ExtAddPairwiseSVecI16x8ToI32x4: + case ExtAddPairwiseUVecI16x8ToI32x4: case TruncSatSVecF32x4ToVecI32x4: case TruncSatUVecF32x4ToVecI32x4: case TruncSatSVecF64x2ToVecI64x2: @@ -200,7 +224,12 @@ case WidenHighSVecI16x8ToVecI32x4: case WidenLowUVecI16x8ToVecI32x4: case WidenHighUVecI16x8ToVecI32x4: - return 1; + case WidenLowSVecI32x4ToVecI64x2: + case WidenHighSVecI32x4ToVecI64x2: + case WidenLowUVecI32x4ToVecI64x2: + case WidenHighUVecI32x4ToVecI64x2: + ret = 1; + break; case InvalidUnary: WASM_UNREACHABLE("invalid unary op"); } @@ -210,8 +239,6 @@ Index ret = 0; switch (curr->op) { case AddInt32: - ret = 1; - break; case SubInt32: ret = 1; break; @@ -219,44 +246,20 @@ 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; @@ -264,44 +267,22 @@ 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; @@ -312,17 +293,9 @@ 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; @@ -333,263 +306,92 @@ ret = 3; break; case CopySignFloat64: - ret = 1; - break; case MinFloat64: - ret = 1; - break; case MaxFloat64: - ret = 1; - break; + case EqInt32: + case NeInt32: 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 EqInt64: + case NeInt64: 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 EqFloat32: + case NeFloat32: case LtFloat32: - ret = 1; - break; case GtFloat32: - ret = 1; - break; case LeFloat32: - ret = 1; - break; case GeFloat32: - ret = 1; - break; + case EqFloat64: + case NeFloat64: 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 EqVecI64x2: 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; @@ -597,35 +399,15 @@ 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; @@ -633,23 +415,16 @@ 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 Q15MulrSatSVecI16x8: + case ExtMulLowSVecI16x8: + case ExtMulHighSVecI16x8: + case ExtMulLowUVecI16x8: + case ExtMulHighUVecI16x8: case AddVecI32x4: - ret = 1; - break; case SubVecI32x4: ret = 1; break; @@ -657,32 +432,22 @@ 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 ExtMulLowSVecI32x4: + case ExtMulHighSVecI32x4: + case ExtMulLowUVecI32x4: + case ExtMulHighUVecI32x4: case AddVecI64x2: - ret = 1; - break; case SubVecI64x2: - ret = 1; - break; case MulVecI64x2: - ret = 1; - break; + case ExtMulLowSVecI64x2: + case ExtMulHighSVecI64x2: + case ExtMulLowUVecI64x2: + case ExtMulHighUVecI64x2: case AddVecF32x4: - ret = 1; - break; case SubVecF32x4: ret = 1; break; @@ -693,20 +458,10 @@ 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; @@ -717,29 +472,13 @@ 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; @@ -749,13 +488,56 @@ return ret + visit(curr->left) + visit(curr->right); } Index visitSelect(Select* curr) { - return 2 + visit(curr->condition) + visit(curr->ifTrue) + + return 1 + 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 visitMemoryGrow(MemoryGrow* curr) { return 100 + visit(curr->delta); } + Index visitMemoryInit(MemoryInit* curr) { + return 6 + visit(curr->dest) + visit(curr->offset) + visit(curr->size); + } + Index visitMemoryCopy(MemoryCopy* curr) { + return 6 + visit(curr->dest) + visit(curr->source) + visit(curr->size); + } + Index visitMemoryFill(MemoryFill* curr) { + return 6 + visit(curr->dest) + visit(curr->value) + visit(curr->size); + } + Index visitSIMDLoad(SIMDLoad* curr) { return 1 + visit(curr->ptr); } + Index visitSIMDLoadStoreLane(SIMDLoadStoreLane* curr) { + return 1 + Index(curr->isStore()) + visit(curr->ptr) + visit(curr->vec); + } + Index visitSIMDReplace(SIMDReplace* curr) { + return 2 + visit(curr->vec) + visit(curr->value); + } + Index visitSIMDExtract(SIMDExtract* curr) { return 1 + visit(curr->vec); } + Index visitSIMDTernary(SIMDTernary* curr) { + Index ret = 0; + switch (curr->op) { + case Bitselect: + case SignSelectVec8x16: + case SignSelectVec16x8: + case SignSelectVec32x4: + case SignSelectVec64x2: + ret = 1; + break; + case QFMAF32x4: + case QFMSF32x4: + case QFMAF64x2: + case QFMSF64x2: + ret = 2; + break; + } + return ret + visit(curr->a) + visit(curr->b) + visit(curr->c); + } + Index visitSIMDShift(SIMDShift* curr) { + return 1 + visit(curr->vec) + visit(curr->shift); + } + Index visitSIMDShuffle(SIMDShuffle* curr) { + return 1 + visit(curr->left) + visit(curr->right); + } + Index visitPrefetch(Prefetch* curr) { return 0 + visit(curr->ptr); } Index visitRefNull(RefNull* curr) { return 1; } Index visitRefIsNull(RefIsNull* curr) { return 1 + visit(curr->value); } Index visitRefFunc(RefFunc* curr) { return 1; } @@ -764,15 +546,86 @@ } Index visitTry(Try* curr) { // We assume no exception will be thrown in most cases - return visit(curr->body); + return visit(curr->body) + maybeVisit(curr->catchBody); } - Index visitThrow(Throw* curr) { return 100; } - Index visitRethrow(Rethrow* curr) { return 100; } + Index visitThrow(Throw* curr) { + Index ret = 100; + for (auto* child : curr->operands) { + ret += visit(child); + } + return ret; + } + Index visitRethrow(Rethrow* curr) { return 100 + visit(curr->exnref); } Index visitBrOnExn(BrOnExn* curr) { return 1 + visit(curr->exnref) + curr->sent.size(); } + Index visitTupleMake(TupleMake* curr) { + Index ret = 0; + for (auto* child : curr->operands) { + ret += visit(child); + } + return ret; + } + Index visitTupleExtract(TupleExtract* curr) { return visit(curr->tuple); } + Index visitPop(Pop* curr) { return 0; } Index visitNop(Nop* curr) { return 0; } Index visitUnreachable(Unreachable* curr) { return 0; } + Index visitDataDrop(DataDrop* curr) { return 5; } + Index visitI31New(I31New* curr) { return 3 + visit(curr->value); } + Index visitI31Get(I31Get* curr) { return 2 + visit(curr->i31); } + Index visitRefTest(RefTest* curr) { + return 2 + nullCheckCost(curr->ref) + visit(curr->ref) + visit(curr->rtt); + } + Index visitRefCast(RefCast* curr) { + return 2 + nullCheckCost(curr->ref) + visit(curr->ref) + visit(curr->rtt); + } + Index visitBrOnCast(BrOnCast* curr) { + return 3 + nullCheckCost(curr->ref) + visit(curr->ref) + visit(curr->rtt); + } + Index visitRttCanon(RttCanon* curr) { + // TODO: investigate actual RTT costs in VMs + return 1; + } + Index visitRttSub(RttSub* curr) { + // TODO: investigate actual RTT costs in VMs + return 2 + visit(curr->parent); + } + Index visitStructNew(StructNew* curr) { + // While allocation itself is almost free with generational GC, there is + // at least some baseline cost, plus writing the fields. (If we use default + // values for the fields, then it is possible they are all 0 and if so, we + // can get that almost for free as well, so don't add anything there.) + Index ret = 4 + visit(curr->rtt) + curr->operands.size(); + for (auto* child : curr->operands) { + ret += visit(child); + } + return ret; + } + Index visitStructGet(StructGet* curr) { + return 1 + nullCheckCost(curr->ref) + visit(curr->ref); + } + Index visitStructSet(StructSet* curr) { + return 2 + nullCheckCost(curr->ref) + visit(curr->ref) + visit(curr->value); + } + Index visitArrayNew(ArrayNew* curr) { + return 4 + visit(curr->rtt) + visit(curr->size) + visit(curr->init); + } + Index visitArrayGet(ArrayGet* curr) { + return 1 + nullCheckCost(curr->ref) + visit(curr->ref) + visit(curr->index); + } + Index visitArraySet(ArraySet* curr) { + return 2 + nullCheckCost(curr->ref) + visit(curr->ref) + + visit(curr->index) + visit(curr->value); + } + Index visitArrayLen(ArrayLen* curr) { + return 1 + nullCheckCost(curr->ref) + visit(curr->ref); + } + +private: + Index nullCheckCost(Expression* ref) { + // A nullable type requires a bounds check in most VMs. + return ref->type.isNullable(); + } }; } // namespace wasm diff --git a/binaryen/src/ir/effects.h b/binaryen/src/ir/effects.h --- a/binaryen/src/ir/effects.h +++ b/binaryen/src/ir/effects.h @@ -25,15 +25,15 @@ // Look for side effects, including control flow // TODO: optimize -struct EffectAnalyzer - : public PostWalker> { +class EffectAnalyzer { +public: EffectAnalyzer(const PassOptions& passOptions, FeatureSet features, Expression* ast = nullptr) : ignoreImplicitTraps(passOptions.ignoreImplicitTraps), debugInfo(passOptions.debugInfo), features(features) { if (ast) { - analyze(ast); + walk(ast); } } @@ -41,12 +41,20 @@ bool debugInfo; FeatureSet features; - void analyze(Expression* ast) { - breakTargets.clear(); - walk(ast); - assert(tryDepth == 0); + // Walk an expression and all its children. + void walk(Expression* ast) { + pre(); + InternalAnalyzer(*this).walk(ast); + post(); } + // Visit an expression, without any children. + void visit(Expression* ast) { + pre(); + InternalAnalyzer(*this).visit(ast); + post(); + } + // Core effect tracking // Definitely branches out of this expression, or does a return, etc. @@ -63,10 +71,14 @@ 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 + // A trap, either from an unreachable instruction, or from an implicit trap + // that we do not ignore (see below). + // Note that we ignore trap differences, so it is ok to reorder traps with + // each other, but it is not ok to remove them or reorder them with other + // effects in a noticeable way. + bool trap = false; + // A trap from an instruction like a load or div/rem, which may trap on corner + // cases. If we do not ignore implicit traps then these are counted as a trap. bool implicitTrap = false; // An atomic load/store/RMW/Cmpxchg or an operator that has a defined ordering // wrt atomics (e.g. memory.grow) @@ -82,38 +94,6 @@ // 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 { @@ -134,21 +114,21 @@ return branchesOut || throws || hasExternalBreakTargets(); } - bool hasGlobalSideEffects() const { - return calls || globalsWritten.size() > 0 || writesMemory || isAtomic || - throws; + // Changes something in globally-stored state. + bool writesGlobalState() const { + return globalsWritten.size() || writesMemory || isAtomic || calls; } + bool readsGlobalState() const { + return globalsRead.size() || readsMemory || isAtomic || calls; + } + bool hasSideEffects() const { - return hasGlobalSideEffects() || localsWritten.size() > 0 || - transfersControlFlow() || implicitTrap || danglingPop; + return localsWritten.size() > 0 || danglingPop || writesGlobalState() || + trap || throws || transfersControlFlow(); } bool hasAnything() const { return hasSideEffects() || accessesLocal() || readsMemory || - accessesGlobal() || isAtomic; - } - - bool noticesGlobalSideEffects() const { - return calls || readsMemory || isAtomic || globalsRead.size(); + accessesGlobal(); } // check if we break to anything external from ourselves @@ -160,7 +140,7 @@ if ((transfersControlFlow() && other.hasSideEffects()) || (other.transfersControlFlow() && hasSideEffects()) || ((writesMemory || calls) && other.accessesMemory()) || - (accessesMemory() && (other.writesMemory || other.calls)) || + ((other.writesMemory || other.calls) && accessesMemory()) || (danglingPop || other.danglingPop)) { return true; } @@ -171,7 +151,7 @@ return true; } for (auto local : localsWritten) { - if (other.localsWritten.count(local) || other.localsRead.count(local)) { + if (other.localsRead.count(local) || other.localsWritten.count(local)) { return true; } } @@ -180,13 +160,13 @@ return true; } } - if ((accessesGlobal() && other.calls) || - (other.accessesGlobal() && calls)) { + if ((other.calls && accessesGlobal()) || + (calls && other.accessesGlobal())) { return true; } for (auto global : globalsWritten) { - if (other.globalsWritten.count(global) || - other.globalsRead.count(global)) { + if (other.globalsRead.count(global) || + other.globalsWritten.count(global)) { return true; } } @@ -195,14 +175,21 @@ return true; } } - // we are ok to reorder implicit traps, but not conditionalize them - if ((implicitTrap && other.transfersControlFlow()) || - (other.implicitTrap && transfersControlFlow())) { + // We are ok to reorder implicit traps, but not conditionalize them. + if ((trap && other.transfersControlFlow()) || + (other.trap && transfersControlFlow())) { return true; } - // we can't reorder an implicit trap in a way that alters global state - if ((implicitTrap && other.hasGlobalSideEffects()) || - (other.implicitTrap && hasGlobalSideEffects())) { + // Note that the above includes disallowing the reordering of a trap with an + // exception (as an exception can transfer control flow inside the current + // function, so transfersControlFlow would be true) - while we allow the + // reordering of traps with each other, we do not reorder exceptions with + // anything. + assert(!((trap && other.throws) || (throws && other.trap))); + // We can't reorder an implicit trap in a way that could alter what global + // state is modified. + if ((trap && other.writesGlobalState()) || + (other.trap && writesGlobalState())) { return true; } return false; @@ -213,6 +200,7 @@ calls = calls || other.calls; readsMemory = readsMemory || other.readsMemory; writesMemory = writesMemory || other.writesMemory; + trap = trap || other.trap; implicitTrap = implicitTrap || other.implicitTrap; isAtomic = isAtomic || other.isAtomic; throws = throws || other.throws; @@ -255,167 +243,205 @@ std::set breakTargets; - void visitBlock(Block* curr) { - if (curr->name.is()) { - breakTargets.erase(curr->name); // these were internal breaks +private: + struct InternalAnalyzer + : public PostWalker> { + + EffectAnalyzer& parent; + + InternalAnalyzer(EffectAnalyzer& parent) : parent(parent) {} + + static void scan(InternalAnalyzer* 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); } - } - void visitIf(If* curr) {} - void visitLoop(Loop* curr) { - if (curr->name.is()) { - breakTargets.erase(curr->name); // these were internal breaks + + static void doStartTry(InternalAnalyzer* self, Expression** currp) { + self->parent.tryDepth++; } - // 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; + + static void doStartCatch(InternalAnalyzer* self, Expression** currp) { + assert(self->parent.tryDepth > 0 && "try depth cannot be negative"); + self->parent.tryDepth--; + self->parent.catchDepth++; } - } - void visitBreak(Break* curr) { breakTargets.insert(curr->name); } - void visitSwitch(Switch* curr) { - for (auto name : curr->targets) { - breakTargets.insert(name); + + static void doEndCatch(InternalAnalyzer* self, Expression** currp) { + assert(self->parent.catchDepth > 0 && "catch depth cannot be negative"); + self->parent.catchDepth--; } - 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; + void visitBlock(Block* curr) { + if (curr->name.is()) { + parent.breakTargets.erase(curr->name); // these were internal breaks + } } - if (curr->isReturn) { - branchesOut = true; + void visitIf(If* curr) {} + void visitLoop(Loop* curr) { + if (curr->name.is()) { + parent.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) { + parent.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 visitBreak(Break* curr) { parent.breakTargets.insert(curr->name); } + void visitSwitch(Switch* curr) { + for (auto name : curr->targets) { + parent.breakTargets.insert(name); + } + parent.breakTargets.insert(curr->default_); } - } - void visitCallIndirect(CallIndirect* curr) { - calls = true; - if (features.hasExceptionHandling() && tryDepth == 0) { - throws = true; + + void visitCall(Call* curr) { + parent.calls = true; + // When EH is enabled, any call can throw. + if (parent.features.hasExceptionHandling() && parent.tryDepth == 0) { + parent.throws = true; + } + if (curr->isReturn) { + parent.branchesOut = true; + } + if (parent.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 + parent.branchesOut = true; + } } - if (curr->isReturn) { - branchesOut = true; + void visitCallIndirect(CallIndirect* curr) { + parent.calls = true; + if (parent.features.hasExceptionHandling() && parent.tryDepth == 0) { + parent.throws = true; + } + if (curr->isReturn) { + parent.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 visitLocalGet(LocalGet* curr) { + parent.localsRead.insert(curr->index); } - } - void visitStore(Store* curr) { - writesMemory = true; - isAtomic |= curr->isAtomic; - if (!ignoreImplicitTraps) { - implicitTrap = true; + void visitLocalSet(LocalSet* curr) { + parent.localsWritten.insert(curr->index); } - } - void visitAtomicRMW(AtomicRMW* curr) { - readsMemory = true; - writesMemory = true; - isAtomic = true; - if (!ignoreImplicitTraps) { - implicitTrap = true; + void visitGlobalGet(GlobalGet* curr) { + parent.globalsRead.insert(curr->name); } - } - void visitAtomicCmpxchg(AtomicCmpxchg* curr) { - readsMemory = true; - writesMemory = true; - isAtomic = true; - if (!ignoreImplicitTraps) { - implicitTrap = true; + void visitGlobalSet(GlobalSet* curr) { + parent.globalsWritten.insert(curr->name); } - } - 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 visitLoad(Load* curr) { + parent.readsMemory = true; + parent.isAtomic |= curr->isAtomic; + parent.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 visitStore(Store* curr) { + parent.writesMemory = true; + parent.isAtomic |= curr->isAtomic; + parent.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 visitAtomicRMW(AtomicRMW* curr) { + parent.readsMemory = true; + parent.writesMemory = true; + parent.isAtomic = true; + parent.implicitTrap = true; } - } - void visitMemoryInit(MemoryInit* curr) { - writesMemory = true; - if (!ignoreImplicitTraps) { - implicitTrap = true; + void visitAtomicCmpxchg(AtomicCmpxchg* curr) { + parent.readsMemory = true; + parent.writesMemory = true; + parent.isAtomic = true; + parent.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 visitAtomicWait(AtomicWait* curr) { + parent.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. + parent.writesMemory = true; + parent.isAtomic = true; + parent.implicitTrap = true; } - } - void visitMemoryCopy(MemoryCopy* curr) { - readsMemory = true; - writesMemory = 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. + parent.readsMemory = true; + parent.writesMemory = true; + parent.isAtomic = true; + parent.implicitTrap = true; } - } - void visitMemoryFill(MemoryFill* curr) { - writesMemory = true; - if (!ignoreImplicitTraps) { - implicitTrap = true; + void visitAtomicFence(AtomicFence* curr) { + // AtomicFence should not be reordered with any memory operations, so we + // set these to true. + parent.readsMemory = true; + parent.writesMemory = true; + parent.isAtomic = true; } - } - void visitConst(Const* curr) {} - void visitUnary(Unary* curr) { - if (!ignoreImplicitTraps) { + void visitSIMDExtract(SIMDExtract* curr) {} + void visitSIMDReplace(SIMDReplace* curr) {} + void visitSIMDShuffle(SIMDShuffle* curr) {} + void visitSIMDTernary(SIMDTernary* curr) {} + void visitSIMDShift(SIMDShift* curr) {} + void visitSIMDLoad(SIMDLoad* curr) { + parent.readsMemory = true; + parent.implicitTrap = true; + } + void visitSIMDLoadStoreLane(SIMDLoadStoreLane* curr) { + if (curr->isLoad()) { + parent.readsMemory = true; + } else { + parent.writesMemory = true; + } + parent.implicitTrap = true; + } + void visitPrefetch(Prefetch* curr) { + // Do not reorder with respect to other memory ops + parent.writesMemory = true; + parent.readsMemory = true; + } + void visitMemoryInit(MemoryInit* curr) { + parent.writesMemory = true; + parent.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. + parent.writesMemory = true; + parent.implicitTrap = true; + } + void visitMemoryCopy(MemoryCopy* curr) { + parent.readsMemory = true; + parent.writesMemory = true; + parent.implicitTrap = true; + } + void visitMemoryFill(MemoryFill* curr) { + parent.writesMemory = true; + parent.implicitTrap = true; + } + void visitConst(Const* curr) {} + void visitUnary(Unary* curr) { switch (curr->op) { case TruncSFloat32ToInt32: case TruncSFloat32ToInt64: @@ -425,16 +451,13 @@ case TruncSFloat64ToInt64: case TruncUFloat64ToInt32: case TruncUFloat64ToInt64: { - implicitTrap = true; + parent.implicitTrap = true; break; } - default: { - } + default: {} } } - } - void visitBinary(Binary* curr) { - if (!ignoreImplicitTraps) { + void visitBinary(Binary* curr) { switch (curr->op) { case DivSInt32: case DivUInt32: @@ -444,100 +467,130 @@ case DivUInt64: case RemSInt64: case RemUInt64: { - implicitTrap = true; + // div and rem may contain implicit trap only if RHS is + // non-constant or constant which equal zero or -1 for + // signed divisions. Reminder traps only with zero + // divider. + if (auto* c = curr->right->dynCast()) { + if (c->value.isZero()) { + parent.implicitTrap = true; + } else if ((curr->op == DivSInt32 || curr->op == DivSInt64) && + c->value.getInteger() == -1LL) { + parent.implicitTrap = true; + } + } else { + parent.implicitTrap = true; + } break; } - default: { - } + 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 visitSelect(Select* curr) {} + void visitDrop(Drop* curr) {} + void visitReturn(Return* curr) { parent.branchesOut = true; } + void visitMemorySize(MemorySize* curr) { + // memory.size accesses the size of the memory, and thus can be modeled as + // reading memory + parent.readsMemory = true; + // Atomics are sequentially consistent with memory.size. + parent.isAtomic = true; } - } - void visitRethrow(Rethrow* curr) { - if (tryDepth == 0) { - throws = true; + void visitMemoryGrow(MemoryGrow* curr) { + parent.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 + parent.readsMemory = true; + parent.writesMemory = true; + // Atomics are also sequentially consistent with memory.grow. + parent.isAtomic = true; } - if (!ignoreImplicitTraps) { // rethrow traps when the arg is null - implicitTrap = 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 (parent.tryDepth == 0) { + parent.throws = true; + } } - } - void visitBrOnExn(BrOnExn* curr) { - breakTargets.insert(curr->name); - if (!ignoreImplicitTraps) { // br_on_exn traps when the arg is null - implicitTrap = true; + void visitRethrow(Rethrow* curr) { + if (parent.tryDepth == 0) { + parent.throws = true; + } + // traps when the arg is null + parent.implicitTrap = true; } - } - void visitNop(Nop* curr) {} - void visitUnreachable(Unreachable* curr) { branchesOut = true; } - void visitPop(Pop* curr) { - if (catchDepth == 0) { - danglingPop = true; + void visitBrOnExn(BrOnExn* curr) { + parent.breakTargets.insert(curr->name); + // traps when the arg is null + parent.implicitTrap = 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"); - } + void visitNop(Nop* curr) {} + void visitUnreachable(Unreachable* curr) { parent.trap = true; } + void visitPop(Pop* curr) { + if (parent.catchDepth == 0) { + parent.danglingPop = true; + } + } + void visitTupleMake(TupleMake* curr) {} + void visitTupleExtract(TupleExtract* curr) {} + void visitI31New(I31New* curr) {} + void visitI31Get(I31Get* curr) {} + void visitCallRef(CallRef* curr) { + parent.calls = true; + if (parent.features.hasExceptionHandling() && parent.tryDepth == 0) { + parent.throws = true; + } + if (curr->isReturn) { + parent.branchesOut = true; + } + // traps when the arg is null + parent.implicitTrap = true; + } + void visitRefTest(RefTest* curr) {} + void visitRefCast(RefCast* curr) { + // Traps if the ref is not null and it has an invalid rtt. + parent.implicitTrap = true; + } + void visitBrOnCast(BrOnCast* curr) { + parent.breakTargets.insert(curr->name); + } + void visitRttCanon(RttCanon* curr) {} + void visitRttSub(RttSub* curr) {} + void visitStructNew(StructNew* curr) {} + void visitStructGet(StructGet* curr) { + // traps when the arg is null + if (curr->ref->type.isNullable()) { + parent.implicitTrap = true; + } + } + void visitStructSet(StructSet* curr) { + // traps when the arg is null + if (curr->ref->type.isNullable()) { + parent.implicitTrap = true; + } + } + void visitArrayNew(ArrayNew* curr) {} + void visitArrayGet(ArrayGet* curr) { + // traps when the arg is null or the index out of bounds + parent.implicitTrap = true; + } + void visitArraySet(ArraySet* curr) { + // traps when the arg is null or the index out of bounds + parent.implicitTrap = true; + } + void visitArrayLen(ArrayLen* curr) { + // traps when the arg is null + if (curr->ref->type.isNullable()) { + parent.implicitTrap = true; + } + } + }; +public: // Helpers static bool canReorder(const PassOptions& passOptions, @@ -611,6 +664,19 @@ void ignoreBranches() { branchesOut = false; breakTargets.clear(); + } + +private: + void pre() { breakTargets.clear(); } + + void post() { + assert(tryDepth == 0); + + if (ignoreImplicitTraps) { + implicitTrap = false; + } else if (implicitTrap) { + trap = true; + } } }; diff --git a/binaryen/src/ir/features.h b/binaryen/src/ir/features.h --- a/binaryen/src/ir/features.h +++ b/binaryen/src/ir/features.h @@ -57,8 +57,6 @@ case AnyTrueVecI32x4: case AllTrueVecI32x4: case NegVecI64x2: - case AnyTrueVecI64x2: - case AllTrueVecI64x2: case AbsVecF32x4: case NegVecF32x4: case SqrtVecF32x4: diff --git a/binaryen/src/ir/global-utils.h b/binaryen/src/ir/global-utils.h --- a/binaryen/src/ir/global-utils.h +++ b/binaryen/src/ir/global-utils.h @@ -56,13 +56,14 @@ inline bool canInitializeGlobal(const Expression* curr) { if (auto* tuple = curr->dynCast()) { for (auto* op : tuple->operands) { - if (!Properties::isSingleConstantExpression(op) && !op->is()) { + if (!canInitializeGlobal(op)) { return false; } } return true; } - return Properties::isSingleConstantExpression(curr) || curr->is(); + return Properties::isSingleConstantExpression(curr) || + curr->is() || curr->is() || curr->is(); } } // namespace GlobalUtils diff --git a/binaryen/src/ir/module-splitting.cpp b/binaryen/src/ir/module-splitting.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/ir/module-splitting.cpp @@ -0,0 +1,595 @@ +/* + * 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. + */ + +// The process of module splitting involves these steps: +// +// 1. Create the new secondary module. +// +// 2. Export globals, events, tables, and memories from the primary module and +// import them in the secondary module. +// +// 3. Move the deferred functions from the primary to the secondary module. +// +// 4. For any secondary function exported from the primary module, export in +// its place a trampoline function that makes an indirect call to its +// placeholder function (and eventually to the original secondary +// function), allocating a new table slot for the placeholder if necessary. +// +// 5. Rewrite direct calls from primary functions to secondary functions to be +// indirect calls to their placeholder functions (and eventually to their +// original secondary functions), allocating new table slots for the +// placeholders if necessary. +// +// 6. For each primary function directly called from a secondary function, +// export the primary function if it is not already exported and import it +// into the secondary module. +// +// 7. Replace all references to secondary functions in the primary module's +// table segments with references to imported placeholder functions. +// +// 8. Create new active table segments in the secondary module that will +// replace all the placeholder function references in the table with +// references to their corresponding secondary functions upon +// instantiation. +// +// Functions can be used or referenced three ways in a WebAssembly module: they +// can be exported, called, or placed in a table. The above procedure introduces +// a layer of indirection to each of those mechanisms that removes all +// references to secondary functions from the primary module but restores the +// original program's semantics once the secondary module is instantiated. As +// more mechanisms that reference functions are added in the future, such as +// ref.func instructions, they will have to be modified to use a similar layer +// of indirection. +// +// The code as currently written makes a few assumptions about the module that +// is being split: +// +// 1. It assumes that mutable-globals is allowed. This could be worked around +// by introducing wrapper functions for globals and rewriting secondary +// code that accesses them, but now that mutable-globals is shipped on all +// browsers, hopefully that extra complexity won't be necessary. +// +// 2. It assumes that either all table segment offsets are constants or there +// is exactly one segment that may have a non-constant offset. It also +// assumes that all segments are active segments (although Binaryen does +// not yet support passive table segments anyway). +// +// 3. It assumes that each function appears in the table at most once. This +// isn't necessarily true in general or even for LLVM output after function +// deduplication. Relaxing this assumption would just require slightly more +// complex code, so it is a good candidate for a follow up PR. + +#include "ir/module-splitting.h" +#include "ir/manipulation.h" +#include "ir/module-utils.h" +#include "ir/names.h" +#include "pass.h" +#include "wasm-builder.h" +#include "wasm.h" + +namespace std { + +// Used in ModuleSplitter::shareImportableItems +template<> struct hash> { + size_t operator()(const pair& p) const { + auto digest = wasm::hash(p.first); + wasm::rehash(digest, p.second); + return digest; + } +}; + +} // namespace std + +namespace wasm { + +namespace ModuleSplitting { + +namespace { + +template void forEachElement(Table& table, F f) { + for (auto& segment : table.segments) { + Name base = ""; + Index offset = 0; + if (auto* c = segment.offset->dynCast()) { + offset = c->value.geti32(); + } else if (auto* g = segment.offset->dynCast()) { + base = g->name; + } + for (size_t i = 0; i < segment.data.size(); ++i) { + f(base, offset + i, segment.data[i]); + } + } +} + +struct TableSlotManager { + struct Slot { + // If `global` is empty, then this slot is at a statically known index. + Name global; + Index index = 0; + + // Generate code to compute the index of this table slot + Expression* makeExpr(Module& module); + }; + Module& module; + Table& table; + Table::Segment* activeSegment = nullptr; + Slot activeBase; + std::map funcIndices; + + TableSlotManager(Module& module); + + // Returns the table index for `func`, allocating a new index if necessary. + Slot getSlot(Name func); + void addSlot(Name func, Slot slot); +}; + +Expression* TableSlotManager::Slot::makeExpr(Module& module) { + Builder builder(module); + auto makeIndex = [&]() { return builder.makeConst(int32_t(index)); }; + if (global.size()) { + Expression* getBase = builder.makeGlobalGet(global, Type::i32); + return index == 0 ? getBase + : builder.makeBinary(AddInt32, getBase, makeIndex()); + } else { + return makeIndex(); + } +} + +void TableSlotManager::addSlot(Name func, Slot slot) { + auto it = funcIndices.insert(std::make_pair(func, slot)); + assert(it.second && "Function already has multiple table slots"); +} + +TableSlotManager::TableSlotManager(Module& module) + : module(module), table(module.table) { + + // If there is exactly one table segment and that segment has a non-constant + // offset, append new items to the end of that segment. In all other cases, + // append new items at constant offsets after all existing items at constant + // offsets. + if (table.segments.size() == 1 && !table.segments[0].offset->is()) { + assert(table.segments[0].offset->is() && + "Unexpected initializer instruction"); + activeSegment = &table.segments[0]; + activeBase = {table.segments[0].offset->cast()->name, 0}; + } else { + // Finds the segment with the highest occupied table slot so that new items + // can be inserted contiguously at the end of it without accidentally + // overwriting any other items. TODO: be more clever about filling gaps in + // the table, if that is ever useful. + Index maxIndex = 0; + for (auto& segment : table.segments) { + assert(segment.offset->is() && + "Unexpected non-const segment offset with multiple segments"); + Index segmentBase = segment.offset->cast()->value.geti32(); + if (segmentBase + segment.data.size() >= maxIndex) { + maxIndex = segmentBase + segment.data.size(); + activeSegment = &segment; + activeBase = {"", segmentBase}; + } + } + } + // Initialize funcIndices with the functions already in the table. + forEachElement(table, [&](Name base, Index offset, Name func) { + addSlot(func, {base, offset}); + }); +} + +TableSlotManager::Slot TableSlotManager::getSlot(Name func) { + auto slotIt = funcIndices.find(func); + if (slotIt != funcIndices.end()) { + return slotIt->second; + } + + // If there are no segments yet, allocate one. + if (activeSegment == nullptr) { + table.exists = true; + assert(table.segments.size() == 0); + table.segments.emplace_back(Builder(module).makeConst(int32_t(0))); + activeSegment = &table.segments.back(); + } + + Slot newSlot = {activeBase.global, + activeBase.index + Index(activeSegment->data.size())}; + activeSegment->data.push_back(func); + addSlot(func, newSlot); + if (table.initial <= newSlot.index) { + table.initial = newSlot.index + 1; + } + if (table.max <= newSlot.index) { + table.max = newSlot.index + 1; + } + return newSlot; +} + +struct ModuleSplitter { + const Config& config; + std::unique_ptr secondaryPtr; + + Module& primary; + Module& secondary; + + const std::pair, std::set> classifiedFuncs; + const std::set& primaryFuncs; + const std::set& secondaryFuncs; + + TableSlotManager tableManager; + + // Map from internal function names to (one of) their corresponding export + // names. + std::map exportedPrimaryFuncs; + + // Initialization helpers + static std::unique_ptr initSecondary(const Module& primary); + static std::pair, std::set> + classifyFunctions(const Module& primary, const Config& config); + static std::map initExportedPrimaryFuncs(const Module& primary); + + // Other helpers + void exportImportFunction(Name func); + + // Main splitting steps + void moveSecondaryFunctions(); + void thunkExportedSecondaryFunctions(); + void indirectCallsToSecondaryFunctions(); + void exportImportCalledPrimaryFunctions(); + void setupTablePatching(); + void shareImportableItems(); + + ModuleSplitter(Module& primary, const Config& config) + : config(config), secondaryPtr(initSecondary(primary)), primary(primary), + secondary(*secondaryPtr), + classifiedFuncs(classifyFunctions(primary, config)), + primaryFuncs(classifiedFuncs.first), + secondaryFuncs(classifiedFuncs.second), tableManager(primary), + exportedPrimaryFuncs(initExportedPrimaryFuncs(primary)) { + moveSecondaryFunctions(); + thunkExportedSecondaryFunctions(); + indirectCallsToSecondaryFunctions(); + exportImportCalledPrimaryFunctions(); + setupTablePatching(); + shareImportableItems(); + } +}; + +std::unique_ptr ModuleSplitter::initSecondary(const Module& primary) { + // Create the secondary module and copy trivial properties. + auto secondary = std::make_unique(); + secondary->features = primary.features; + secondary->hasFeaturesSection = primary.hasFeaturesSection; + return secondary; +} + +std::pair, std::set> +ModuleSplitter::classifyFunctions(const Module& primary, const Config& config) { + std::set primaryFuncs, secondaryFuncs; + for (auto& func : primary.functions) { + if (func->imported() || config.primaryFuncs.count(func->name)) { + primaryFuncs.insert(func->name); + } else { + assert(func->name != primary.start && "The start function must be kept"); + secondaryFuncs.insert(func->name); + } + } + return std::make_pair(primaryFuncs, secondaryFuncs); +} + +std::map +ModuleSplitter::initExportedPrimaryFuncs(const Module& primary) { + std::map functionExportNames; + for (auto& ex : primary.exports) { + if (ex->kind == ExternalKind::Function) { + functionExportNames[ex->value] = ex->name; + } + } + return functionExportNames; +} + +void ModuleSplitter::exportImportFunction(Name funcName) { + Name exportName; + // If the function is already exported, use the existing export name. + // Otherwise, create a new export for it. + auto exportIt = exportedPrimaryFuncs.find(funcName); + if (exportIt != exportedPrimaryFuncs.end()) { + exportName = exportIt->second; + } else { + exportName = Names::getValidExportName( + primary, config.newExportPrefix + funcName.c_str()); + primary.addExport( + Builder::makeExport(exportName, funcName, ExternalKind::Function)); + exportedPrimaryFuncs[funcName] = exportName; + } + // Import the function if it is not already imported into the secondary + // module. + if (secondary.getFunctionOrNull(funcName) == nullptr) { + auto func = + Builder::makeFunction(funcName, primary.getFunction(funcName)->sig, {}); + func->module = config.importNamespace; + func->base = exportName; + secondary.addFunction(std::move(func)); + } +} + +void ModuleSplitter::moveSecondaryFunctions() { + // Move the specified functions from the primary to the secondary module. + for (auto funcName : secondaryFuncs) { + auto* func = primary.getFunction(funcName); + ModuleUtils::copyFunction(func, secondary); + primary.removeFunction(funcName); + } +} + +void ModuleSplitter::thunkExportedSecondaryFunctions() { + // Update exports of secondary functions in the primary module to export + // wrapper functions that indirectly call the secondary functions. We are + // adding secondary function names to the primary table here, but they will be + // replaced with placeholder functions later along with any references to + // secondary functions that were already in the table. + Builder builder(primary); + for (auto& ex : primary.exports) { + if (ex->kind != ExternalKind::Function || + !secondaryFuncs.count(ex->value)) { + continue; + } + Name secondaryFunc = ex->value; + if (primary.getFunctionOrNull(secondaryFunc)) { + // We've already created a thunk for this function + continue; + } + auto tableSlot = tableManager.getSlot(secondaryFunc); + auto func = std::make_unique(); + + func->name = secondaryFunc; + func->sig = secondary.getFunction(secondaryFunc)->sig; + std::vector args; + for (size_t i = 0, size = func->sig.params.size(); i < size; ++i) { + args.push_back(builder.makeLocalGet(i, func->sig.params[i])); + } + func->body = + builder.makeCallIndirect(tableSlot.makeExpr(primary), args, func->sig); + primary.addFunction(std::move(func)); + } +} + +void ModuleSplitter::indirectCallsToSecondaryFunctions() { + // Update direct calls of secondary functions to be indirect calls of their + // corresponding table indices instead. + struct CallIndirector : public WalkerPass> { + ModuleSplitter& parent; + Builder builder; + CallIndirector(ModuleSplitter& parent) + : parent(parent), builder(parent.primary) {} + void visitCall(Call* curr) { + if (!parent.secondaryFuncs.count(curr->target)) { + return; + } + replaceCurrent(builder.makeCallIndirect( + parent.tableManager.getSlot(curr->target).makeExpr(parent.primary), + curr->operands, + parent.secondary.getFunction(curr->target)->sig, + curr->isReturn)); + } + void visitRefFunc(RefFunc* curr) { + assert(false && "TODO: handle ref.func as well"); + } + }; + PassRunner runner(&primary); + CallIndirector(*this).run(&runner, &primary); +} + +void ModuleSplitter::exportImportCalledPrimaryFunctions() { + // Find primary functions called in the secondary module. + ModuleUtils::ParallelFunctionAnalysis> callCollector( + secondary, [&](Function* func, std::vector& calledPrimaryFuncs) { + struct CallCollector : PostWalker { + const std::set& primaryFuncs; + std::vector& calledPrimaryFuncs; + CallCollector(const std::set& primaryFuncs, + std::vector& calledPrimaryFuncs) + : primaryFuncs(primaryFuncs), calledPrimaryFuncs(calledPrimaryFuncs) { + } + void visitCall(Call* curr) { + if (primaryFuncs.count(curr->target)) { + calledPrimaryFuncs.push_back(curr->target); + } + } + void visitRefFunc(RefFunc* curr) { + assert(false && "TODO: handle ref.func as well"); + } + }; + CallCollector(primaryFuncs, calledPrimaryFuncs).walkFunction(func); + }); + std::set calledPrimaryFuncs; + for (auto& entry : callCollector.map) { + auto& calledFuncs = entry.second; + calledPrimaryFuncs.insert(calledFuncs.begin(), calledFuncs.end()); + } + + // Ensure each called primary function is exported and imported + for (auto func : calledPrimaryFuncs) { + exportImportFunction(func); + } +} + +void ModuleSplitter::setupTablePatching() { + std::map replacedElems; + // Replace table references to secondary functions with an imported + // placeholder that encodes the table index in its name: + // `importNamespace`.`index`. + forEachElement(primary.table, [&](Name, Index index, Name& elem) { + if (secondaryFuncs.count(elem)) { + replacedElems[index] = elem; + auto* secondaryFunc = secondary.getFunction(elem); + auto placeholder = std::make_unique(); + placeholder->module = config.placeholderNamespace; + placeholder->base = std::to_string(index); + placeholder->name = Names::getValidFunctionName( + primary, + std::string("placeholder_") + std::string(placeholder->base.c_str())); + placeholder->hasExplicitName = false; + placeholder->sig = secondaryFunc->sig; + elem = placeholder->name; + primary.addFunction(std::move(placeholder)); + } + }); + + if (replacedElems.size() == 0) { + // No placeholders to patch out of the table + return; + } + + if (tableManager.activeBase.global.size()) { + assert(primary.table.segments.size() == 1 && + "Unexpected number of segments with non-const base"); + assert(secondary.table.segments.size() == 0); + // Since addition is not currently allowed in initializer expressions, we + // need to start the new secondary segment where the primary segment starts. + // The secondary segment will contain the same primary functions as the + // primary module except in positions where it needs to overwrite a + // placeholder function. All primary functions in the table therefore need + // to be imported into the second module. TODO: use better strategies here, + // such as using ref.func in the start function or standardizing addition in + // initializer expressions. + const Table::Segment& primarySeg = primary.table.segments.front(); + std::vector secondaryElems; + secondaryElems.reserve(primarySeg.data.size()); + + // Copy functions from the primary segment to the secondary segment, + // replacing placeholders and creating new exports and imports as necessary. + auto replacement = replacedElems.begin(); + for (Index i = 0; + i < primarySeg.data.size() && replacement != replacedElems.end(); + ++i) { + if (replacement->first == i) { + // primarySeg.data[i] is a placeholder, so use the secondary function. + secondaryElems.push_back(replacement->second); + ++replacement; + } else { + exportImportFunction(primarySeg.data[i]); + secondaryElems.push_back(primarySeg.data[i]); + } + } + + auto offset = ExpressionManipulator::copy(primarySeg.offset, secondary); + secondary.table.segments.emplace_back(offset, secondaryElems); + return; + } + + // Create active table segments in the secondary module to patch in the + // original functions when it is instantiated. + Index currBase = replacedElems.begin()->first; + std::vector currData; + auto finishSegment = [&]() { + auto* offset = Builder(secondary).makeConst(int32_t(currBase)); + secondary.table.segments.emplace_back(offset, currData); + }; + for (auto curr = replacedElems.begin(); curr != replacedElems.end(); ++curr) { + if (curr->first != currBase + currData.size()) { + finishSegment(); + currBase = curr->first; + currData.clear(); + } + currData.push_back(curr->second); + } + if (currData.size()) { + finishSegment(); + } +} + +void ModuleSplitter::shareImportableItems() { + // Map internal names to (one of) their corresponding export names. Don't + // consider functions because they have already been imported and exported as + // necessary. + std::unordered_map, Name> exports; + for (auto& ex : primary.exports) { + if (ex->kind != ExternalKind::Function) { + exports[std::make_pair(ex->kind, ex->value)] = ex->name; + } + } + + auto makeImportExport = [&](Importable& primaryItem, + Importable& secondaryItem, + const std::string& genericExportName, + ExternalKind kind) { + secondaryItem.name = primaryItem.name; + secondaryItem.hasExplicitName = primaryItem.hasExplicitName; + secondaryItem.module = config.importNamespace; + auto exportIt = exports.find(std::make_pair(kind, primaryItem.name)); + if (exportIt != exports.end()) { + secondaryItem.base = exportIt->second; + } else { + Name exportName = Names::getValidExportName( + primary, config.newExportPrefix + genericExportName); + primary.addExport(new Export{exportName, primaryItem.name, kind}); + secondaryItem.base = exportName; + } + }; + + // TODO: Be more selective by only sharing global items that are actually used + // in the secondary module, just like we do for functions. + + if (primary.memory.exists) { + secondary.memory.exists = true; + secondary.memory.initial = primary.memory.initial; + secondary.memory.max = primary.memory.max; + secondary.memory.shared = primary.memory.shared; + secondary.memory.indexType = primary.memory.indexType; + makeImportExport( + primary.memory, secondary.memory, "memory", ExternalKind::Memory); + } + + if (primary.table.exists) { + secondary.table.exists = true; + secondary.table.initial = primary.table.initial; + secondary.table.max = primary.table.max; + makeImportExport( + primary.table, secondary.table, "table", ExternalKind::Table); + } + + for (auto& global : primary.globals) { + if (global->mutable_) { + assert(primary.features.hasMutableGlobals() && + "TODO: add wrapper functions for disallowed mutable globals"); + } + auto secondaryGlobal = std::make_unique(); + secondaryGlobal->type = global->type; + secondaryGlobal->mutable_ = global->mutable_; + secondaryGlobal->init = + global->init == nullptr + ? nullptr + : ExpressionManipulator::copy(global->init, secondary); + makeImportExport(*global, *secondaryGlobal, "global", ExternalKind::Global); + secondary.addGlobal(std::move(secondaryGlobal)); + } + + for (auto& event : primary.events) { + auto secondaryEvent = std::make_unique(); + secondaryEvent->attribute = event->attribute; + secondaryEvent->sig = event->sig; + makeImportExport(*event, *secondaryEvent, "event", ExternalKind::Event); + secondary.addEvent(std::move(secondaryEvent)); + } +} + +} // anonymous namespace + +std::unique_ptr splitFunctions(Module& primary, const Config& config) { + return std::move(ModuleSplitter(primary, config).secondaryPtr); +} + +} // namespace ModuleSplitting + +} // namespace wasm diff --git a/binaryen/src/ir/module-splitting.h b/binaryen/src/ir/module-splitting.h new file mode 100644 --- /dev/null +++ b/binaryen/src/ir/module-splitting.h @@ -0,0 +1,76 @@ +/* + * 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. + */ + +// module-splitting.h: Provides an interface for decomposing WebAssembly modules +// into multiple modules that can be loaded independently. This works by moving +// functions to a new secondary module and rewriting the primary module to call +// them indirectly. Until the secondary module is instantiated, those indirect +// calls will go to placeholder functions newly imported into the primary +// module. If the primary module has a single segment with a non-constant +// offset, the placeholder function import names are the offsets from that base +// global of the corresponding functions in the table. Otherwise, the +// placeholder import names are the absolute table indices of the corresponding +// functions. The secondary module imports all of its dependencies from the +// primary module. +// +// This code currently makes a few assumptions about the modules that will be +// split and will fail assertions if those assumptions are not true. +// +// 1) It assumes that mutable-globals are allowed. +// +// 2) It assumes that either all segment offsets are constants or there is +// exactly one segment that may have a non-constant offset. +// +// 3) It assumes that each function appears in the table at most once. +// +// These requirements will be relaxed as necessary in the future, but for now +// this code should be considered experimental and used with care. + +#ifndef wasm_ir_module_splitting_h +#define wasm_ir_module_splitting_h + +#include "wasm.h" + +namespace wasm { + +namespace ModuleSplitting { + +struct Config { + // The set of functions to keep in the primary module. All others are split + // out into the new secondary module. Must include the start function if it + // exists. May or may not include imported functions, which are always kept in + // the primary module regardless. + std::set primaryFuncs; + // The namespace from which to import primary functions into the secondary + // module. + Name importNamespace = "primary"; + // The namespace from which to import placeholder functions into the primary + // module. + Name placeholderNamespace = "placeholder"; + // The prefix to attach to the name of any newly created exports. This can be + // used to differentiate between "real" exports of the module and exports that + // should only be consumed by the secondary module. + std::string newExportPrefix = ""; +}; + +// Returns the new secondary module and modifies the `primary` module in place. +std::unique_ptr splitFunctions(Module& primary, const Config& config); + +} // namespace ModuleSplitting + +} // namespace wasm + +#endif // wasm_ir_module_splitting_h diff --git a/binaryen/src/ir/module-utils.h b/binaryen/src/ir/module-utils.h --- a/binaryen/src/ir/module-utils.h +++ b/binaryen/src/ir/module-utils.h @@ -308,7 +308,9 @@ struct FunctionInfo { std::set callsTo; std::set calledBy; - bool hasIndirectCall = false; + // A non-direct call is any call that is not direct. That includes + // CallIndirect and CallRef. + bool hasNonDirectCall = false; }; typedef std::map Map; @@ -329,10 +331,10 @@ void visitCall(Call* curr) { info.callsTo.insert(module->getFunction(curr->target)); } - void visitCallIndirect(CallIndirect* curr) { - info.hasIndirectCall = true; + info.hasNonDirectCall = true; } + void visitCallRef(CallRef* curr) { info.hasNonDirectCall = true; } private: Module* module; @@ -354,7 +356,7 @@ } } - enum IndirectCalls { IgnoreIndirectCalls, IndirectCallsHaveProperty }; + enum NonDirectCalls { IgnoreNonDirectCalls, NonDirectCallsHaveProperty }; // Propagate a property from a function to those that call it. // @@ -365,13 +367,13 @@ void propagateBack(std::function hasProperty, std::function canHaveProperty, std::function addProperty, - IndirectCalls indirectCalls) { + NonDirectCalls nonDirectCalls) { // 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)) { + (nonDirectCalls == NonDirectCallsHaveProperty && + map[func.get()].hasNonDirectCall)) { addProperty(map[func.get()], func.get()); work.push(func.get()); } @@ -390,19 +392,33 @@ } }; -// Helper function for collecting the type signatures used in a module +// Helper function for collecting all the types that are declared in a module, +// which means the HeapTypes (that are non-basic, that is, not eqref etc., which +// do not need to be defined). // -// Used when emitting or printing a module to give signatures canonical -// indices. Signatures are sorted in order of decreasing frequency to minize the +// Used when emitting or printing a module to give HeapTypes canonical +// indices. HeapTypes 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; +// HeapTypes and a map mapping HeapTypes to indices are produced. +inline void collectHeapTypes(Module& wasm, + std::vector& types, + std::unordered_map& typeIndices) { + struct Counts : public std::unordered_map { + bool isRelevant(Type type) { + if (type.isRef()) { + return !type.getHeapType().isBasic(); + } + return type.isRtt(); + } + void note(HeapType type) { (*this)[type]++; } + void maybeNote(Type type) { + if (isRelevant(type)) { + note(type.getHeapType()); + } + } + }; - // Collect the signature use counts for a single function + // Collect the type use counts for a single function auto updateCounts = [&](Function* func, Counts& counts) { if (func->imported()) { return; @@ -412,13 +428,23 @@ Counts& counts; TypeCounter(Counts& counts) : counts(counts) {} + void visitExpression(Expression* curr) { if (auto* call = curr->dynCast()) { - counts[call->sig]++; + counts.note(call->sig); + } else if (curr->is()) { + counts.maybeNote(curr->type); + } else if (curr->is() || curr->is()) { + counts.note(curr->type.getRtt().heapType); + } else if (auto* get = curr->dynCast()) { + counts.maybeNote(get->ref->type); + } else if (auto* set = curr->dynCast()) { + counts.maybeNote(set->ref->type); } else if (Properties::isControlFlowStructure(curr)) { - // TODO: Allow control flow to have input types as well + counts.maybeNote(curr->type); if (curr->type.isTuple()) { - counts[Signature(Type::none, curr->type)]++; + // TODO: Allow control flow to have input types as well + counts.note(Signature(Type::none, curr->type)); } } } @@ -431,29 +457,127 @@ // Collect all the counts. Counts counts; for (auto& curr : wasm.functions) { - counts[curr->sig]++; + counts.note(curr->sig); + for (auto type : curr->vars) { + counts.maybeNote(type); + if (type.isTuple()) { + for (auto t : type) { + counts.maybeNote(t); + } + } + } } for (auto& curr : wasm.events) { - counts[curr->sig]++; + counts.note(curr->sig); } + for (auto& curr : wasm.globals) { + counts.maybeNote(curr->type); + } 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()); + // A generic utility to traverse the child types of a type. + // TODO: work with tlively to refactor this to a shared place + auto walkRelevantChildren = [&](HeapType type, + std::function callback) { + auto callIfRelevant = [&](Type type) { + if (counts.isRelevant(type)) { + callback(type.getHeapType()); + } + }; + if (type.isSignature()) { + auto sig = type.getSignature(); + for (Type type : {sig.params, sig.results}) { + for (auto element : type) { + callIfRelevant(element); + } + } + } else if (type.isArray()) { + callIfRelevant(type.getArray().element.type); + } else if (type.isStruct()) { + auto fields = type.getStruct().fields; + for (auto field : fields) { + callIfRelevant(field.type); + } + } + }; + // Recursively traverse each reference type, which may have a child type that + // is itself a reference type. This reflects an appearance in the binary + // format that is in the type section itself. + // As we do this we may find more and more types, as nested children of + // previous ones. Each such type will appear in the type section once, so + // we just need to visit it once. + // TODO: handle struct and array fields + std::unordered_set newTypes; + for (auto& pair : counts) { + newTypes.insert(pair.first); + } + while (!newTypes.empty()) { + auto iter = newTypes.begin(); + auto type = *iter; + newTypes.erase(iter); + walkRelevantChildren(type, [&](HeapType type) { + if (!counts.count(type)) { + newTypes.insert(type); + } + counts.note(type); + }); + } + + // We must sort all the dependencies of a type before it. For example, + // (func (param (ref (func)))) must appear after (func). To do that, find the + // depth of dependencies of each type. For example, if A depends on B + // which depends on C, then A's depth is 2, B's is 1, and C's is 0 (assuming + // no other dependencies). + Counts depthOfDependencies; + std::unordered_map> isDependencyOf; + // To calculate the depth of dependencies, we'll do a flow analysis, visiting + // each type as we find out new things about it. + std::set toVisit; + for (auto& pair : counts) { + auto type = pair.first; + depthOfDependencies[type] = 0; + toVisit.insert(type); + walkRelevantChildren(type, [&](HeapType childType) { + isDependencyOf[childType].insert(type); // XXX flip? + }); + } + while (!toVisit.empty()) { + auto iter = toVisit.begin(); + auto type = *iter; + toVisit.erase(iter); + // Anything that depends on this has a depth of dependencies equal to this + // type's, plus this type itself. + auto newDepth = depthOfDependencies[type] + 1; + if (newDepth > counts.size()) { + Fatal() << "Cyclic types detected, cannot sort them."; + } + for (auto& other : isDependencyOf[type]) { + if (depthOfDependencies[other] < newDepth) { + // We found something new to propagate. + depthOfDependencies[other] = newDepth; + toVisit.insert(other); + } + } + } + // Sort by frequency and then simplicity, and also keeping every type + // before things that depend on it. + std::vector> sorted(counts.begin(), counts.end()); std::sort(sorted.begin(), sorted.end(), [&](auto a, auto b) { - // order by frequency then simplicity + if (depthOfDependencies[a.first] != depthOfDependencies[b.first]) { + return depthOfDependencies[a.first] < depthOfDependencies[b.first]; + } 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); + typeIndices[sorted[i].first] = i; + types.push_back(sorted[i].first); } } diff --git a/binaryen/src/ir/names.h b/binaryen/src/ir/names.h --- a/binaryen/src/ir/names.h +++ b/binaryen/src/ir/names.h @@ -46,6 +46,41 @@ } } +// Given a root of a name, finds a valid name with perhaps a number appended +// to it, by calling a function to check if a name is valid. +inline Name +getValidName(Module& module, Name root, std::function check) { + if (check(root)) { + return root; + } + auto prefixed = std::string(root.str) + '_'; + Index num = 0; + while (1) { + auto name = prefixed + std::to_string(num); + if (check(name)) { + return name; + } + num++; + } +} + +inline Name getValidExportName(Module& module, Name root) { + return getValidName( + module, root, [&](Name test) { return !module.getExportOrNull(test); }); +} +inline Name getValidGlobalName(Module& module, Name root) { + return getValidName( + module, root, [&](Name test) { return !module.getGlobalOrNull(test); }); +} +inline Name getValidFunctionName(Module& module, Name root) { + return getValidName( + module, root, [&](Name test) { return !module.getFunctionOrNull(test); }); +} +inline Name getValidEventName(Module& module, Name root) { + return getValidName( + module, root, [&](Name test) { return !module.getEventOrNull(test); }); +} + } // namespace Names } // namespace wasm diff --git a/binaryen/src/ir/properties.h b/binaryen/src/ir/properties.h --- a/binaryen/src/ir/properties.h +++ b/binaryen/src/ir/properties.h @@ -19,6 +19,7 @@ #include "ir/bits.h" #include "ir/effects.h" +#include "ir/match.h" #include "wasm.h" namespace wasm { @@ -79,6 +80,10 @@ return false; } +// A constant expression is something like a Const: it has a fixed value known +// at compile time, and passes that propagate constants can try to propagate it. +// Constant expressions are also allowed in global initializers in wasm. +// TODO: look into adding more things here like RttCanon. inline bool isSingleConstantExpression(const Expression* curr) { return curr->is() || curr->is() || curr->is() || (curr->is() && curr->cast()->value->is()); @@ -105,7 +110,7 @@ } else if (auto* n = curr->dynCast()) { return Literal(n->type); } else if (auto* r = curr->dynCast()) { - return Literal(r->func); + return Literal(r->func, r->type); } else if (auto* i = curr->dynCast()) { if (auto* c = i->value->dynCast()) { return Literal::makeI31(c->value.geti32()); @@ -131,84 +136,81 @@ // 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; - } - } - } - } - } - } - } + // We only care about i32s here, and ignore i64s, unreachables, etc. + if (curr->type != Type::i32) { + return nullptr; } + using namespace Match; + int32_t leftShift = 0, rightShift = 0; + Expression* extended = nullptr; + if (matches(curr, + binary(ShrSInt32, + binary(ShlInt32, any(&extended), i32(&leftShift)), + i32(&rightShift))) && + leftShift == rightShift && leftShift != 0) { + return extended; + } return nullptr; } // gets the size of the sign-extended value inline Index getSignExtBits(Expression* curr) { - return 32 - Bits::getEffectiveShifts(curr->cast()->right); + assert(curr->type == Type::i32); + auto* rightShift = curr->cast()->right; + return 32 - Bits::getEffectiveShifts(rightShift); } // 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; - } - } - } - } - } - } - } + using namespace Match; + int32_t leftShift = 0, rightShift = 0; + Expression* extended = nullptr; + if (matches(curr, + binary(ShrSInt32, + binary(ShlInt32, any(&extended), i32(&leftShift)), + i32(&rightShift))) && + Bits::getEffectiveShifts(rightShift, Type::i32) <= + Bits::getEffectiveShifts(leftShift, Type::i32) && + rightShift != 0) { + return extended; } 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); +inline Index getAlmostSignExtBits(Expression* curr, Index& extraLeftShifts) { + auto* leftShift = curr->cast()->left->cast()->right; + auto* rightShift = curr->cast()->right; + extraLeftShifts = + Bits::getEffectiveShifts(leftShift) - Bits::getEffectiveShifts(rightShift); 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; - } - } - } + // We only care about i32s here, and ignore i64s, unreachables, etc. + if (curr->type != Type::i32) { + return nullptr; } + using namespace Match; + int32_t mask = 0; + Expression* extended = nullptr; + if (matches(curr, binary(AndInt32, any(&extended), i32(&mask))) && + Bits::getMaskedBits(mask) != 0) { + return extended; + } return nullptr; } // gets the size of the sign-extended value inline Index getZeroExtBits(Expression* curr) { - return Bits::getMaskedBits( - curr->cast()->right->cast()->value.geti32()); + assert(curr->type == Type::i32); + int32_t mask = curr->cast()->right->cast()->value.geti32(); + return Bits::getMaskedBits(mask); } // Returns a falling-through value, that is, it looks through a local.tee diff --git a/binaryen/src/ir/type-updating.h b/binaryen/src/ir/type-updating.h --- a/binaryen/src/ir/type-updating.h +++ b/binaryen/src/ir/type-updating.h @@ -17,6 +17,7 @@ #ifndef wasm_ir_type_updating_h #define wasm_ir_type_updating_h +#include "ir/branch-utils.h" #include "wasm-traversal.h" namespace wasm { @@ -56,17 +57,11 @@ if (block->name.is()) { blockInfos[block->name].block = block; } - } else if (auto* br = curr->dynCast()) { - // ensure info exists, discoverBreaks can then fill it - blockInfos[br->name]; - } else if (auto* sw = curr->dynCast()) { - // ensure info exists, discoverBreaks can then fill it - for (auto target : sw->targets) { - blockInfos[target]; - } - blockInfos[sw->default_]; - } else if (auto* br = curr->dynCast()) { - blockInfos[br->name]; + } else { + BranchUtils::operateOnScopeNameUses(curr, [&](Name& name) { + // ensure info exists, discoverBreaks can then fill it + blockInfos[name]; + }); } // add a break to the info, for break and switch discoverBreaks(curr, +1); @@ -147,32 +142,22 @@ discoverBreaks(curr, parent ? +1 : -1); } - // adds (or removes) breaks depending on break/switch contents - void discoverBreaks(Expression* curr, int change) { - if (auto* br = curr->dynCast()) { - noteBreakChange(br->name, change, br->value); - } else if (auto* sw = curr->dynCast()) { - applySwitchChanges(sw, change); - } else if (auto* br = curr->dynCast()) { - noteBreakChange(br->name, change, br->sent); - } - } - - void applySwitchChanges(Switch* sw, int change) { - std::set seen; - for (auto target : sw->targets) { - if (seen.insert(target).second) { - noteBreakChange(target, change, sw->value); - } - } - if (seen.insert(sw->default_).second) { - noteBreakChange(sw->default_, change, sw->value); + // Applies a type change to a node, and potentially to its parents. + void changeType(Expression* curr, Type type) { + if (curr->type != type) { + curr->type = type; + propagateTypesUp(curr); } } - // note the addition of a node - void noteBreakChange(Name name, int change, Expression* value) { - noteBreakChange(name, change, value ? value->type : Type::none); + // adds (or removes) breaks depending on break/switch contents + void discoverBreaks(Expression* curr, int change) { + BranchUtils::operateOnScopeNameUsesAndSentTypes( + curr, + [&](Name& name, Type type) { noteBreakChange(name, change, type); }); + // TODO: it may be faster to accumulate all changes to a set first, then + // call noteBreakChange on the unique values, as a switch can be quite + // large and have lots of repeated targets. } void noteBreakChange(Name name, int change, Type type) { @@ -313,6 +298,10 @@ if (curr->type == Type::unreachable) { propagateTypesUp(curr); } + } + + bool hasBreaks(Block* block) { + return block->name.is() && blockInfos[block->name].numBreaks > 0; } }; diff --git a/binaryen/src/ir/utils.h b/binaryen/src/ir/utils.h --- a/binaryen/src/ir/utils.h +++ b/binaryen/src/ir/utils.h @@ -111,70 +111,11 @@ std::map breakValues; - 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 visitDrop(Drop* 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 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); +#define DELEGATE(CLASS_TO_VISIT) \ + void visit##CLASS_TO_VISIT(CLASS_TO_VISIT* curr); +#include "wasm-delegations.h" + void visitFunction(Function* curr); void visitExport(Export* curr); @@ -195,69 +136,10 @@ // Re-finalize a single node. This is slow, if you want to refinalize // an entire ast, use ReFinalize struct ReFinalizeNode : public OverriddenVisitor { - void visitBlock(Block* curr) { curr->finalize(); } - void visitIf(If* curr) { curr->finalize(); } - void visitLoop(Loop* curr) { curr->finalize(); } - void visitBreak(Break* curr) { curr->finalize(); } - void visitSwitch(Switch* curr) { curr->finalize(); } - void visitCall(Call* curr) { curr->finalize(); } - void visitCallIndirect(CallIndirect* curr) { curr->finalize(); } - void visitLocalGet(LocalGet* curr) { curr->finalize(); } - void visitLocalSet(LocalSet* curr) { curr->finalize(); } - void visitGlobalGet(GlobalGet* curr) { curr->finalize(); } - void visitGlobalSet(GlobalSet* curr) { curr->finalize(); } - void visitLoad(Load* curr) { curr->finalize(); } - void visitStore(Store* curr) { curr->finalize(); } - void visitAtomicRMW(AtomicRMW* curr) { curr->finalize(); } - void visitAtomicCmpxchg(AtomicCmpxchg* curr) { curr->finalize(); } - void visitAtomicWait(AtomicWait* curr) { curr->finalize(); } - void visitAtomicNotify(AtomicNotify* curr) { curr->finalize(); } - void visitAtomicFence(AtomicFence* curr) { curr->finalize(); } - void visitSIMDExtract(SIMDExtract* curr) { curr->finalize(); } - void visitSIMDReplace(SIMDReplace* curr) { curr->finalize(); } - void visitSIMDShuffle(SIMDShuffle* curr) { curr->finalize(); } - void visitSIMDTernary(SIMDTernary* curr) { curr->finalize(); } - void visitSIMDShift(SIMDShift* curr) { curr->finalize(); } - void visitSIMDLoad(SIMDLoad* curr) { curr->finalize(); } - void visitMemoryInit(MemoryInit* curr) { curr->finalize(); } - void visitDataDrop(DataDrop* curr) { curr->finalize(); } - void visitMemoryCopy(MemoryCopy* curr) { curr->finalize(); } - void visitMemoryFill(MemoryFill* curr) { curr->finalize(); } - void visitConst(Const* curr) { curr->finalize(); } - void visitUnary(Unary* curr) { curr->finalize(); } - void visitBinary(Binary* curr) { curr->finalize(); } - void visitSelect(Select* curr) { curr->finalize(); } - void visitDrop(Drop* curr) { curr->finalize(); } - void visitReturn(Return* curr) { curr->finalize(); } - void visitMemorySize(MemorySize* curr) { curr->finalize(); } - void visitMemoryGrow(MemoryGrow* curr) { curr->finalize(); } - void visitRefNull(RefNull* curr) { curr->finalize(); } - void visitRefIsNull(RefIsNull* curr) { curr->finalize(); } - void visitRefFunc(RefFunc* curr) { curr->finalize(); } - void visitRefEq(RefEq* curr) { curr->finalize(); } - void visitTry(Try* curr) { curr->finalize(); } - void visitThrow(Throw* curr) { curr->finalize(); } - void visitRethrow(Rethrow* curr) { curr->finalize(); } - void visitBrOnExn(BrOnExn* curr) { curr->finalize(); } - void visitNop(Nop* curr) { curr->finalize(); } - void visitUnreachable(Unreachable* curr) { curr->finalize(); } - void visitPop(Pop* curr) { curr->finalize(); } - void visitTupleMake(TupleMake* curr) { curr->finalize(); } - void visitTupleExtract(TupleExtract* curr) { curr->finalize(); } - void visitI31New(I31New* curr) { curr->finalize(); } - void visitI31Get(I31Get* curr) { curr->finalize(); } - void visitRefTest(RefTest* curr) { curr->finalize(); } - void visitRefCast(RefCast* curr) { curr->finalize(); } - void visitBrOnCast(BrOnCast* curr) { curr->finalize(); } - void visitRttCanon(RttCanon* curr) { curr->finalize(); } - void visitRttSub(RttSub* curr) { curr->finalize(); } - void visitStructNew(StructNew* curr) { curr->finalize(); } - void visitStructGet(StructGet* curr) { curr->finalize(); } - void visitStructSet(StructSet* curr) { curr->finalize(); } - void visitArrayNew(ArrayNew* curr) { curr->finalize(); } - void visitArrayGet(ArrayGet* curr) { curr->finalize(); } - void visitArraySet(ArraySet* curr) { curr->finalize(); } - void visitArrayLen(ArrayLen* curr) { curr->finalize(); } +#define DELEGATE(CLASS_TO_VISIT) \ + void visit##CLASS_TO_VISIT(CLASS_TO_VISIT* curr) { curr->finalize(); } + +#include "wasm-delegations.h" void visitExport(Export* curr) { WASM_UNREACHABLE("unimp"); } void visitGlobal(Global* curr) { WASM_UNREACHABLE("unimp"); } diff --git a/binaryen/src/js/binaryen.js-post.js b/binaryen/src/js/binaryen.js-post.js --- a/binaryen/src/js/binaryen.js-post.js +++ b/binaryen/src/js/binaryen.js-post.js @@ -9,7 +9,7 @@ } function strToStack(str) { - return str ? allocate(intArrayFromString(str), 'i8', ALLOC_STACK) : 0; + return str ? allocate(intArrayFromString(str), ALLOC_STACK) : 0; } function i32sToStack(i32s) { @@ -99,6 +99,7 @@ 'Pop', 'I31New', 'I31Get', + 'CallRef', 'RefTest', 'RefCast', 'BrOnCast', @@ -415,8 +416,6 @@ 'MaxSVecI32x4', 'MaxUVecI32x4', 'NegVecI64x2', - 'AnyTrueVecI64x2', - 'AllTrueVecI64x2', 'ShlVecI64x2', 'ShrSVecI64x2', 'ShrUVecI64x2', @@ -629,6 +628,17 @@ }, 'fill'(dest, value, size) { return Module['_BinaryenMemoryFill'](module, dest, value, size); + }, + 'atomic': { + 'notify'(ptr, notifyCount) { + return Module['_BinaryenAtomicNotify'](module, ptr, notifyCount); + }, + 'wait32'(ptr, expected, timeout) { + return Module['_BinaryenAtomicWait'](module, ptr, expected, timeout, Module['i32']); + }, + 'wait64'(ptr, expected, timeout) { + return Module['_BinaryenAtomicWait'](module, ptr, expected, timeout, Module['i64']); + } } } @@ -889,9 +899,6 @@ return Module['_BinaryenAtomicCmpxchg'](module, 2, offset, ptr, expected, replacement, Module['i32']) }, }, - 'wait'(ptr, expected, timeout) { - return Module['_BinaryenAtomicWait'](module, ptr, expected, timeout, Module['i32']); - } }, 'pop'() { return Module['_BinaryenPop'](module, Module['i32']); @@ -1193,9 +1200,6 @@ return Module['_BinaryenAtomicCmpxchg'](module, 4, offset, ptr, expected, replacement, Module['i64']) }, }, - 'wait'(ptr, expected, timeout) { - return Module['_BinaryenAtomicWait'](module, ptr, expected, timeout, Module['i64']); - } }, 'pop'() { return Module['_BinaryenPop'](module, Module['i64']); @@ -1822,12 +1826,6 @@ 'neg'(value) { return Module['_BinaryenUnary'](module, Module['NegVecI64x2'], value); }, - 'any_true'(value) { - return Module['_BinaryenUnary'](module, Module['AnyTrueVecI64x2'], value); - }, - 'all_true'(value) { - return Module['_BinaryenUnary'](module, Module['AllTrueVecI64x2'], value); - }, 'shl'(vec, shift) { return Module['_BinaryenSIMDShift'](module, Module['ShlVecI64x2'], vec, shift); }, @@ -2107,8 +2105,8 @@ 'is_null'(value) { return Module['_BinaryenRefIsNull'](module, value); }, - 'func'(func) { - return preserveStack(() => Module['_BinaryenRefFunc'](module, strToStack(func))); + 'func'(func, type) { + return preserveStack(() => Module['_BinaryenRefFunc'](module, strToStack(func), type)); }, 'eq'(left, right) { return Module['_BinaryenRefEq'](module, left, right); @@ -2132,9 +2130,6 @@ }; self['atomic'] = { - 'notify'(ptr, notifyCount) { - return Module['_BinaryenAtomicNotify'](module, ptr, notifyCount); - }, 'fence'() { return Module['_BinaryenAtomicFence'](module); } @@ -2289,7 +2284,7 @@ const segmentOffset = new Array(segmentsLen); for (let i = 0; i < segmentsLen; i++) { const { data, offset, passive } = segments[i]; - segmentData[i] = allocate(data, 'i8', ALLOC_STACK); + segmentData[i] = allocate(data, ALLOC_STACK); segmentDataLen[i] = data.length; segmentPassive[i] = passive; segmentOffset[i] = offset; @@ -2337,18 +2332,27 @@ Module['_BinaryenAddCustomSection'](module, strToStack(name), i8sToStack(contents), contents.length) ); }; + self['getExport'] = function(externalName) { + return preserveStack(() => Module['_BinaryenGetExport'](module, strToStack(externalName))); + }; self['getNumExports'] = function() { return Module['_BinaryenGetNumExports'](module); - } - self['getExportByIndex'] = function(id) { - return Module['_BinaryenGetExportByIndex'](module, id); - } + }; + self['getExportByIndex'] = function(index) { + return Module['_BinaryenGetExportByIndex'](module, index); + }; self['getNumFunctions'] = function() { return Module['_BinaryenGetNumFunctions'](module); - } - self['getFunctionByIndex'] = function(id) { - return Module['_BinaryenGetFunctionByIndex'](module, id); - } + }; + self['getFunctionByIndex'] = function(index) { + return Module['_BinaryenGetFunctionByIndex'](module, index); + }; + self['getNumGlobals'] = function() { + return Module['_BinaryenGetNumGlobals'](module); + }; + self['getGlobalByIndex'] = function(index) { + return Module['_BinaryenGetGlobalByIndex'](module, index); + }; self['emitText'] = function() { const old = out; let ret = ''; @@ -2990,7 +2994,7 @@ Object.defineProperty(Module, 'readBinary', { writable: true }); Module['readBinary'] = function(data) { - const buffer = allocate(data, 'i8', ALLOC_NORMAL); + const buffer = allocate(data, ALLOC_NORMAL); const ptr = Module['_BinaryenModuleRead'](buffer, data.length); _free(buffer); return wrapModule(ptr); diff --git a/binaryen/src/literal.h b/binaryen/src/literal.h --- a/binaryen/src/literal.h +++ b/binaryen/src/literal.h @@ -31,6 +31,10 @@ class Literals; struct ExceptionPackage; +struct GCData; +// Subclass the vector type so that this is not easily confused with a vector of +// types (which could be confusing on the Literal constructor). +struct RttSupers : std::vector {}; class Literal { // store only integers, whose bits are deterministic. floats @@ -43,6 +47,24 @@ Name func; // exnref package. `nullptr` indicates a `null` value. std::unique_ptr exn; + // A reference to GC data, either a Struct or an Array. For both of those + // we store the referred data as a Literals object (which is natural for an + // Array, and for a Struct, is just the fields in order). The type is used + // to indicate whether this is a Struct or an Array, and of what type. + std::shared_ptr gcData; + // RTT values are "structural" in that the MVP doc says that multiple + // invocations of ref.canon return things that are observably identical, and + // the same is true for ref.sub. That is, what matters is the types; there + // is no unique identifier created in each ref.canon/sub. To track the + // types, we maintain a simple vector of the supertypes. Thus, an rtt.canon + // of type A will have an empty vector; an rtt.sub of type B of that initial + // canon would have a vector of size 1 containing A; a subsequent rtt.sub + // would have A, B, and so forth. + // (This encoding is very inefficient and not at all what a production VM + // would do, but it is simple.) + // The unique_ptr here is to avoid increasing the size of the union as well + // as the Literal class itself. + std::unique_ptr rttSupers; // TODO: Literals of type `externref` can only be `null` currently but we // will need to represent extern values eventually, to // 1) run the spec tests and fuzzer with reference types enabled and @@ -55,7 +77,7 @@ Literal() : v128(), type(Type::none) {} explicit Literal(Type type); - explicit Literal(Type::BasicID typeId) : Literal(Type(typeId)) {} + explicit Literal(Type::BasicType type) : Literal(Type(type)) {} explicit Literal(int32_t init) : i32(init), type(Type::i32) {} explicit Literal(uint32_t init) : i32(init), type(Type::i32) {} explicit Literal(int64_t init) : i64(init), type(Type::i64) {} @@ -71,16 +93,14 @@ explicit Literal(const std::array&); explicit Literal(const std::array&); explicit Literal(const std::array&); - explicit Literal(Name func) : func(func), type(Type::funcref) {} + explicit Literal(Name func, Type type) : func(func), type(type) {} explicit Literal(std::unique_ptr&& exn) : exn(std::move(exn)), type(Type::exnref) {} + explicit Literal(std::shared_ptr gcData, Type type); + explicit Literal(std::unique_ptr&& rttSupers, Type type); Literal(const Literal& other); Literal& operator=(const Literal& other); - ~Literal() { - if (type.isException()) { - exn.~unique_ptr(); - } - } + ~Literal(); bool isConcrete() const { return type != Type::none; } bool isNone() const { return type == Type::none; } @@ -92,6 +112,9 @@ if (type.isException()) { return !exn; } + if (isGCData()) { + return !gcData; + } return true; } return false; @@ -114,6 +137,18 @@ WASM_UNREACHABLE("unexpected type"); } } + bool isNegative() const { + switch (type.getBasic()) { + case Type::i32: + case Type::f32: + return i32 < 0; + case Type::i64: + case Type::f64: + return i64 < 0; + default: + WASM_UNREACHABLE("unexpected type"); + } + } bool isSignedMin() const { switch (type.getBasic()) { case Type::i32: @@ -144,6 +179,7 @@ WASM_UNREACHABLE("unexpected type"); } } + bool isGCData() const { return type.isStruct() || type.isArray(); } static Literals makeZeros(Type type); static Literals makeOnes(Type type); @@ -221,7 +257,9 @@ assert(type.isNullable()); return Literal(type); } - static Literal makeFunc(Name func) { return Literal(func.c_str()); } + static Literal makeFunc(Name func, Type type = Type::funcref) { + return Literal(func, type); + } static Literal makeExn(std::unique_ptr&& exn) { return Literal(std::move(exn)); } @@ -262,6 +300,8 @@ return func; } ExceptionPackage getExceptionPackage() const; + std::shared_ptr getGCData() const; + const RttSupers& getRttSupers() const; // careful! int32_t* geti32Ptr() { @@ -451,6 +491,7 @@ Literal leUI32x4(const Literal& other) const; Literal geSI32x4(const Literal& other) const; Literal geUI32x4(const Literal& other) const; + Literal eqI64x2(const Literal& other) const; Literal eqF32x4(const Literal& other) const; Literal neF32x4(const Literal& other) const; Literal ltF32x4(const Literal& other) const; @@ -488,6 +529,7 @@ Literal maxSI8x16(const Literal& other) const; Literal maxUI8x16(const Literal& other) const; Literal avgrUI8x16(const Literal& other) const; + Literal popcntI8x16() const; Literal absI16x8() const; Literal negI16x8() const; Literal anyTrueI16x8() const; @@ -508,6 +550,11 @@ Literal maxSI16x8(const Literal& other) const; Literal maxUI16x8(const Literal& other) const; Literal avgrUI16x8(const Literal& other) const; + Literal q15MulrSatSI16x8(const Literal& other) const; + Literal extMulLowSI16x8(const Literal& other) const; + Literal extMulHighSI16x8(const Literal& other) const; + Literal extMulLowUI16x8(const Literal& other) const; + Literal extMulHighUI16x8(const Literal& other) const; Literal absI32x4() const; Literal negI32x4() const; Literal anyTrueI32x4() const; @@ -524,15 +571,21 @@ Literal maxSI32x4(const Literal& other) const; Literal maxUI32x4(const Literal& other) const; Literal dotSI16x8toI32x4(const Literal& other) const; + Literal extMulLowSI32x4(const Literal& other) const; + Literal extMulHighSI32x4(const Literal& other) const; + Literal extMulLowUI32x4(const Literal& other) const; + Literal extMulHighUI32x4(const Literal& other) const; Literal negI64x2() const; - Literal anyTrueI64x2() const; - Literal allTrueI64x2() const; Literal shlI64x2(const Literal& other) const; Literal shrSI64x2(const Literal& other) const; Literal shrUI64x2(const Literal& other) const; Literal addI64x2(const Literal& other) const; Literal subI64x2(const Literal& other) const; Literal mulI64x2(const Literal& other) const; + Literal extMulLowSI64x2(const Literal& other) const; + Literal extMulHighSI64x2(const Literal& other) const; + Literal extMulLowUI64x2(const Literal& other) const; + Literal extMulHighUI64x2(const Literal& other) const; Literal absF32x4() const; Literal negF32x4() const; Literal sqrtF32x4() const; @@ -585,6 +638,11 @@ Literal widenHighUToVecI32x4() const; Literal swizzleVec8x16(const Literal& other) const; + // Checks if an RTT value is a sub-rtt of another, that is, whether GC data + // with this object's RTT can be successfuly cast using the other RTT + // according to the wasm rules for that. + bool isSubRtt(const Literal& other) const; + private: Literal addSatSI8(const Literal& other) const; Literal addSatUI8(const Literal& other) const; @@ -611,7 +669,9 @@ assert(lit.isConcrete()); } #endif - }; + } + Literals(size_t initialSize) : SmallVector(initialSize) {} + Type getType() { std::vector types; for (auto& val : *this) { @@ -640,6 +700,14 @@ std::ostream& operator<<(std::ostream& o, wasm::Literals literals); std::ostream& operator<<(std::ostream& o, const ExceptionPackage& exn); +// A GC Struct or Array is a set of values with a run-time type saying what it +// is. +struct GCData { + Literal rtt; + Literals values; + GCData(Literal rtt, Literals values) : rtt(rtt), values(values) {} +}; + } // namespace wasm namespace std { @@ -702,7 +770,12 @@ } else if (a.type.isRef()) { return hashRef(); } else if (a.type.isRtt()) { - WASM_UNREACHABLE("TODO: rtt literals"); + const auto& supers = a.getRttSupers(); + wasm::rehash(digest, supers.size()); + for (auto super : supers) { + wasm::rehash(digest, super.getID()); + } + return digest; } WASM_UNREACHABLE("unexpected type"); } diff --git a/binaryen/src/parsing.h b/binaryen/src/parsing.h --- a/binaryen/src/parsing.h +++ b/binaryen/src/parsing.h @@ -22,12 +22,11 @@ #include #include -#include "asmjs/shared-constants.h" #include "mixed_arena.h" #include "shared-constants.h" #include "support/colors.h" #include "support/utilities.h" -#include "wasm-printing.h" +#include "wasm-traversal.h" #include "wasm.h" namespace wasm { diff --git a/binaryen/src/pass.h b/binaryen/src/pass.h --- a/binaryen/src/pass.h +++ b/binaryen/src/pass.h @@ -69,14 +69,15 @@ // More generally, with 2 items we may have a local.get, but no way to // require it to be saved instead of directly consumed. Index alwaysInlineMaxSize = 2; - // Function size which we inline when functions are lightweight (no loops - // and calls) and we are doing aggressive optimisation for speed (-O3). - // In particular it's nice that with this limit we can inline the clamp - // functions (i32s-div, f64-to-int, etc.), that can affect perf. - Index flexibleInlineMaxSize = 20; // Function size which we inline when there is only one caller. // FIXME: this should logically be higher than flexibleInlineMaxSize. Index oneCallerInlineMaxSize = 15; + // Function size above which we never inline, ignoring the various flexible + // factors (like whether we are optimizing for size or speed) that could + // influence us. + // This is checked after alwaysInlineMaxSize and oneCallerInlineMaxSize, but + // the order normally won't matter. + Index flexibleInlineMaxSize = 20; // Loops usually mean the function does heavy work, so the call overhead // is not significant and we do not inline such functions by default. bool allowFunctionsWithLoops = false; @@ -107,6 +108,15 @@ // forth (which IEEE floats do not, strictly speaking). This is inspired by // gcc/clang's -ffast-math flag. bool fastMath = false; + // Whether to assume that an imported memory is zero-initialized. Without + // this, we can do fewer optimizations on memory segments, because if memory + // *was* modified then the wasm's segments may trample those previous + // modifications. If memory was zero-initialized then we can remove zeros from + // the wasm's segments. + // (This is not a problem if the memory is *not* imported, since then wasm + // creates it and we know it is all zeros right before the active segments are + // applied.) + bool zeroFilledMemory = false; // Whether to try to preserve debug info through, which are special calls. bool debugInfo = false; // Arbitrary string arguments from the commandline, which we forward to @@ -226,9 +236,11 @@ // doesn't help anyhow and also is bad for e.g. printing // which is a pass) // this method returns whether we are in passDebug mode, and which value: - // 1: run pass by pass, validating in between - // 2: also save the last pass, so it breakage happens we can print the last - // one 3: also dump out byn-* files for each pass + // 1: log out each pass that we run, and validate in between (can pass + // --no-validation to skip validation). + // 2: like 1, and also save the last pass's output, so if breakage happens we + // can print a useful error. also logs out names of nested passes. + // 3: like 1, and also dumps out byn-* files for each pass as it is run. static int getPassDebug(); protected: @@ -255,10 +267,6 @@ class Pass { public: virtual ~Pass() = default; - - // Override this to perform preparation work before the pass runs. - // This will be called before the pass is run on a module. - virtual void prepareToRun(PassRunner* runner, Module* module) {} // Implement this with code to run the pass on the whole module virtual void run(PassRunner* runner, Module* module) { diff --git a/binaryen/src/passes/Asyncify.cpp b/binaryen/src/passes/Asyncify.cpp --- a/binaryen/src/passes/Asyncify.cpp +++ b/binaryen/src/passes/Asyncify.cpp @@ -677,7 +677,7 @@ } info.canChangeState = true; }, - scanner.IgnoreIndirectCalls); + scanner.IgnoreNonDirectCalls); map.swap(scanner.map); @@ -1408,8 +1408,10 @@ bool allImportsCanChangeState = stateChangingImports == "" && ignoreImports == ""; String::Split listedImports(stateChangingImports, ","); - auto ignoreIndirect = runner->options.getArgumentOrDefault( - "asyncify-ignore-indirect", "") == ""; + // TODO: consider renaming asyncify-ignore-indirect to + // asyncify-ignore-nondirect, but that could break users. + auto ignoreNonDirect = runner->options.getArgumentOrDefault( + "asyncify-ignore-indirect", "") == ""; std::string removeListInput = runner->options.getArgumentOrDefault("asyncify-removelist", ""); if (removeListInput.empty()) { @@ -1462,7 +1464,7 @@ // Scan the module. ModuleAnalyzer analyzer(*module, canImportChangeState, - ignoreIndirect, + ignoreNonDirect, removeList, addList, onlyList, @@ -1488,6 +1490,7 @@ // because the flow changes add many branches, break up if-elses, etc., // all of which extend the live ranges of locals. In other words, it is // not possible to coalesce well afterwards. + runner.add("remove-unused-names"); runner.add("simplify-locals-nonesting"); runner.add("reorder-locals"); runner.add("coalesce-locals"); @@ -1569,9 +1572,9 @@ builder.makeIf(builder.makeBinary(GtUInt32, stackPos, stackEnd), builder.makeUnreachable())); body->finalize(); - auto* func = builder.makeFunction( + auto func = builder.makeFunction( name, Signature(Type(params), Type::none), {}, body); - module->addFunction(func); + module->addFunction(std::move(func)); module->addExport(builder.makeExport(name, name, ExternalKind::Function)); }; diff --git a/binaryen/src/passes/CMakeLists.txt b/binaryen/src/passes/CMakeLists.txt --- a/binaryen/src/passes/CMakeLists.txt +++ b/binaryen/src/passes/CMakeLists.txt @@ -25,7 +25,6 @@ DuplicateImportElimination.cpp DuplicateFunctionElimination.cpp DWARF.cpp - EmscriptenPIC.cpp ExtractFunction.cpp Flatten.cpp FuncCastEmulation.cpp @@ -39,6 +38,7 @@ LocalCSE.cpp LogExecution.cpp LoopInvariantCodeMotion.cpp + Memory64Lowering.cpp MemoryPacking.cpp MergeBlocks.cpp MergeLocals.cpp @@ -64,7 +64,6 @@ RemoveImports.cpp RemoveMemory.cpp RemoveNonJSOps.cpp - ReplaceStackPointer.cpp RemoveUnusedBrs.cpp RemoveUnusedNames.cpp RemoveUnusedModuleElements.cpp @@ -76,7 +75,6 @@ SimplifyGlobals.cpp SimplifyLocals.cpp Souperify.cpp - SpillPointers.cpp StackCheck.cpp SSAify.cpp Untee.cpp diff --git a/binaryen/src/passes/CodePushing.cpp b/binaryen/src/passes/CodePushing.cpp --- a/binaryen/src/passes/CodePushing.cpp +++ b/binaryen/src/passes/CodePushing.cpp @@ -160,7 +160,7 @@ firstPushable < pushPoint); // everything that matters if you want to be pushed past the pushPoint EffectAnalyzer cumulativeEffects(passOptions, features); - cumulativeEffects.analyze(list[pushPoint]); + cumulativeEffects.walk(list[pushPoint]); // it is ok to ignore the branching here, that is the crucial point of this // opt // TODO: it would be ok to ignore thrown exceptions here, if we know they @@ -194,7 +194,7 @@ } } else { // something that can't be pushed, so it might block further pushing - cumulativeEffects.analyze(list[i]); + cumulativeEffects.walk(list[i]); } assert(i > 0); i--; diff --git a/binaryen/src/passes/DeadArgumentElimination.cpp b/binaryen/src/passes/DeadArgumentElimination.cpp --- a/binaryen/src/passes/DeadArgumentElimination.cpp +++ b/binaryen/src/passes/DeadArgumentElimination.cpp @@ -72,7 +72,11 @@ // see inhibits our optimizations, but TODO: an export // could be worked around by exporting a thunk that // adds the parameter. - bool hasUnseenCalls = false; + // This is atomic so that we can write to it from any function at any time + // during the parallel analysis phase which is run in DAEScanner. + std::atomic hasUnseenCalls; + + DAEFunctionInfo() { hasUnseenCalls = false; } }; typedef std::unordered_map DAEFunctionInfoMap; @@ -139,12 +143,29 @@ } } + void visitCallRef(CallRef* curr) { + if (curr->isReturn) { + info->hasTailCalls = true; + } + } + void visitDrop(Drop* curr) { if (auto* call = curr->value->dynCast()) { info->droppedCalls[call] = getCurrentPointer(); } } + void visitRefFunc(RefFunc* curr) { + // We can't modify another function in parallel. + assert((*infoMap).count(curr->func)); + // Treat a ref.func as an unseen call, preventing us from changing the + // function's type. If we did change it, it could be an observable + // difference from the outside, if the reference escapes, for example. + // TODO: look for actual escaping? + // TODO: create a thunk for external uses that allow internal optimizations + (*infoMap)[curr->func].hasUnseenCalls = true; + } + // main entry point void doWalkFunction(Function* func) { @@ -152,14 +173,22 @@ 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 there are relevant params, check if they are used. If we can't + // optimize the function anyhow, there's no point (note that our check here + // is technically racy - another thread could update hasUnseenCalls to true + // around when we check it - but that just means that we might or might not + // do some extra work, as we'll ignore the results later if we have unseen + // calls. That is, the check for hasUnseenCalls here is just a minor + // optimization to avoid pointless work. We can avoid that work if either + // we know there is an unseen call before the parallel analysis that we are + // part of, say if we are exported, or if another parallel function finds a + // RefFunc to us and updates it before we check it). if (numParams > 0 && !info->hasUnseenCalls) { - findUnusedParams(func); + findUnusedParams(); } } - void findUnusedParams(Function* func) { + void findUnusedParams() { // 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. @@ -242,8 +271,9 @@ DAEFunctionInfoMap infoMap; // Ensure they all exist so the parallel threads don't modify the data // structure. - ModuleUtils::iterDefinedFunctions( - *module, [&](Function* func) { infoMap[func->name]; }); + for (auto& func : module->functions) { + infoMap[func->name]; + } // Check the influence of the table and exports. for (auto& curr : module->exports) { if (curr->kind == ExternalKind::Function) { @@ -326,6 +356,9 @@ for (auto& pair : allCalls) { auto name = pair.first; auto& calls = pair.second; + if (infoMap[name].hasUnseenCalls) { + continue; + } auto* func = module->getFunction(name); auto numParams = func->getNumParams(); if (numParams == 0) { diff --git a/binaryen/src/passes/DeadCodeElimination.cpp b/binaryen/src/passes/DeadCodeElimination.cpp --- a/binaryen/src/passes/DeadCodeElimination.cpp +++ b/binaryen/src/passes/DeadCodeElimination.cpp @@ -28,8 +28,8 @@ // have no side effects. // -#include -#include +#include +#include #include #include #include @@ -39,7 +39,9 @@ namespace wasm { struct DeadCodeElimination - : public WalkerPass> { + : public WalkerPass< + PostWalker>> { bool isFunctionParallel() override { return true; } Pass* create() override { return new DeadCodeElimination; } @@ -58,514 +60,116 @@ 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); + void visitExpression(Expression* curr) { + if (!Properties::isControlFlowStructure(curr)) { + // Control flow structures require special handling, but others are + // simple. + if (curr->type == Type::unreachable) { + // This may be dead code. Check if there is an unreachable child. + bool hasUnreachableChild = false; + for (auto* child : ChildIterator(curr)) { + if (child->type == Type::unreachable) { + hasUnreachableChild = true; + break; + } + } + if (hasUnreachableChild) { + // This is indeed unreachable code, made unreachable by that child. + Builder builder(*getModule()); + std::vector remainingChildren; + bool afterUnreachable = false; + for (auto* child : ChildIterator(curr)) { + if (afterUnreachable) { + typeUpdater.noteRecursiveRemoval(child); + continue; + } + if (child->type == Type::unreachable) { + remainingChildren.push_back(child); + afterUnreachable = true; + } else { + remainingChildren.push_back(builder.makeDrop(child)); + } + } + if (remainingChildren.size() == 1) { + replaceCurrent(remainingChildren[0]); + } else { + replaceCurrent(builder.makeBlock(remainingChildren)); + } + } } 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++) { + // This is a control flow structure. + if (auto* block = curr->dynCast()) { + auto& list = block->list; + // The index from which to remove, which is one after the first + // unreachable instruction. Note that 0 is not a valid value, so we can + // use it as such. + Index removeFromHere = 0; + for (Index i = 0; i < list.size(); i++) { if (list[i]->type == Type::unreachable) { - list.resize(i + 1); + removeFromHere = 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]); + if (removeFromHere != 0) { + for (Index i = removeFromHere; i < list.size(); i++) { + typeUpdater.noteRecursiveRemoval(list[i]); } + list.resize(removeFromHere); + if (list.size() == 1 && list[0]->is()) { + replaceCurrent(list[0]); + return; + } } - } - 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)); + // Finally, if there is no need for a concrete type (which is when there + // is one marked, but nothing breaks to it, and also the block does not + // have a concrete value flowing out) then remove it, which may allow + // more reduction. + if (block->type.isConcrete() && list.back()->type == Type::unreachable && + !typeUpdater.hasBreaks(block)) { + typeUpdater.changeType(block, Type::unreachable); } - 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; + } else if (auto* iff = curr->dynCast()) { + if (iff->condition->type == Type::unreachable) { + typeUpdater.noteRecursiveRemoval(iff->ifTrue); + if (iff->ifFalse) { + typeUpdater.noteRecursiveRemoval(iff->ifFalse); } - replaceCurrent(replacement); + replaceCurrent(iff->condition); return; } + // If both arms are unreachable, there is no need for a concrete type, + // which may allow more reduction. + if (iff->type != Type::unreachable && iff->ifFalse && + iff->ifTrue->type == Type::unreachable && + iff->ifFalse->type == Type::unreachable) { + typeUpdater.changeType(iff, Type::unreachable); + } + } else if (auto* loop = curr->dynCast()) { + // The loop body may have unreachable type if it branches back to the + // loop top, for example. The only case we look for here is where we've + // already removed the entire body as dead code. + if (loop->body->is()) { + replaceCurrent(loop->body); + } + } else if (auto* tryy = curr->dynCast()) { + // If both try body and catch body are unreachable, there is no need for a + // concrete type, which may allow more reduction. + if (tryy->type != Type::unreachable && + tryy->body->type == Type::unreachable && + tryy->catchBody->type == Type::unreachable) { + typeUpdater.changeType(tryy, Type::unreachable); + } + } else { + WASM_UNREACHABLE("unimplemented DCE control flow structure"); } } - - 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(); } diff --git a/binaryen/src/passes/Directize.cpp b/binaryen/src/passes/Directize.cpp --- a/binaryen/src/passes/Directize.cpp +++ b/binaryen/src/passes/Directize.cpp @@ -22,7 +22,6 @@ #include -#include "asm_v_wasm.h" #include "ir/table-utils.h" #include "ir/utils.h" #include "pass.h" @@ -42,6 +41,9 @@ FunctionDirectizer(TableUtils::FlatTable* flatTable) : flatTable(flatTable) {} void visitCallIndirect(CallIndirect* curr) { + if (!flatTable) { + return; + } if (auto* c = curr->target->dynCast()) { Index index = c->value.geti32(); // If the index is invalid, or the type is wrong, we can @@ -69,6 +71,15 @@ } } + void visitCallRef(CallRef* curr) { + if (auto* ref = curr->target->dynCast()) { + // We know the target! + replaceCurrent( + Builder(*getModule()) + .makeCall(ref->func, curr->operands, curr->type, curr->isReturn)); + } + } + void doWalkFunction(Function* func) { WalkerPass>::doWalkFunction(func); if (changedTypes) { @@ -77,7 +88,9 @@ } private: + // If null, then we cannot optimize call_indirects. TableUtils::FlatTable* flatTable; + bool changedTypes = false; void replaceWithUnreachable(CallIndirect* call) { @@ -93,23 +106,31 @@ struct Directize : public Pass { void run(PassRunner* runner, Module* module) override { + bool canOptimizeCallIndirect = true; + TableUtils::FlatTable flatTable(module->table); if (!module->table.exists) { - return; - } - if (module->table.imported()) { - return; - } - for (auto& ex : module->exports) { - if (ex->kind == ExternalKind::Table) { - return; + canOptimizeCallIndirect = false; + } else if (module->table.imported()) { + canOptimizeCallIndirect = false; + } else { + for (auto& ex : module->exports) { + if (ex->kind == ExternalKind::Table) { + canOptimizeCallIndirect = false; + } } + if (!flatTable.valid) { + canOptimizeCallIndirect = false; + } } - TableUtils::FlatTable flatTable(module->table); - if (!flatTable.valid) { + // Without typed function references, all we can do is optimize table + // accesses, so if we can't do that, stop. + if (!canOptimizeCallIndirect && + !module->features.hasTypedFunctionReferences()) { return; } // The table exists and is constant, so this is possible. - FunctionDirectizer(&flatTable).run(runner, module); + FunctionDirectizer(canOptimizeCallIndirect ? &flatTable : nullptr) + .run(runner, module); } }; diff --git a/binaryen/src/passes/DuplicateImportElimination.cpp b/binaryen/src/passes/DuplicateImportElimination.cpp --- a/binaryen/src/passes/DuplicateImportElimination.cpp +++ b/binaryen/src/passes/DuplicateImportElimination.cpp @@ -20,7 +20,6 @@ // TODO: non-function imports too // -#include "asm_v_wasm.h" #include "ir/import-utils.h" #include "opt-utils.h" #include "pass.h" diff --git a/binaryen/src/passes/EmscriptenPIC.cpp b/binaryen/src/passes/EmscriptenPIC.cpp deleted file mode 100644 --- a/binaryen/src/passes/EmscriptenPIC.cpp +++ /dev/null @@ -1,221 +0,0 @@ -/* - * 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/Flatten.cpp b/binaryen/src/passes/Flatten.cpp --- a/binaryen/src/passes/Flatten.cpp +++ b/binaryen/src/passes/Flatten.cpp @@ -17,6 +17,8 @@ // // Flattens code into "Flat IR" form. See ir/flat.h. // +// TODO: handle non-nullability +// #include #include diff --git a/binaryen/src/passes/FuncCastEmulation.cpp b/binaryen/src/passes/FuncCastEmulation.cpp --- a/binaryen/src/passes/FuncCastEmulation.cpp +++ b/binaryen/src/passes/FuncCastEmulation.cpp @@ -28,7 +28,8 @@ // params must be identical, i.e., the "ABI" must match. // -#include +#include + #include #include #include @@ -36,11 +37,6 @@ 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); @@ -134,20 +130,23 @@ : public WalkerPass> { bool isFunctionParallel() override { return true; } - Pass* create() override { return new ParallelFuncCastEmulation(ABIType); } + Pass* create() override { + return new ParallelFuncCastEmulation(ABIType, numParams); + } - ParallelFuncCastEmulation(Signature ABIType) : ABIType(ABIType) {} + ParallelFuncCastEmulation(Signature ABIType, Index numParams) + : ABIType(ABIType), numParams(numParams) {} void visitCallIndirect(CallIndirect* curr) { - if (curr->operands.size() > NUM_PARAMS) { - Fatal() << "FuncCastEmulation::NUM_PARAMS needs to be at least " + if (curr->operands.size() > numParams) { + Fatal() << "max-func-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) { + while (curr->operands.size() < numParams) { curr->operands.push_back(LiteralUtils::makeZero(Type::i64, *getModule())); } // Set the new types @@ -162,20 +161,22 @@ private: // The signature of a call with the right params and return Signature ABIType; + Index numParams; }; struct FuncCastEmulation : public Pass { void run(PassRunner* runner, Module* module) override { + Index numParams = + std::stoul(runner->options.getArgumentOrDefault("max-func-params", "16")); // we just need the one ABI function type for all indirect calls - Signature ABIType(Type(std::vector(NUM_PARAMS, Type::i64)), - Type::i64); + Signature ABIType(Type(std::vector(numParams, 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); + auto thunk = makeThunk(name, module, numParams); funcThunks[name] = thunk; name = thunk; } else { @@ -184,12 +185,12 @@ } } // update call_indirects - ParallelFuncCastEmulation(ABIType).run(runner, module); + ParallelFuncCastEmulation(ABIType, numParams).run(runner, module); } private: // Creates a thunk for a function, casting args and return value as needed. - Name makeThunk(Name name, Module* module) { + Name makeThunk(Name name, Module* module, Index numParams) { Name thunk = std::string("byn$fpcast-emu$") + name.str; if (module->getFunctionOrNull(thunk)) { Fatal() << "FuncCastEmulation::makeThunk seems a thunk name already in " @@ -207,15 +208,15 @@ } auto* call = builder.makeCall(name, callOperands, type); std::vector thunkParams; - for (Index i = 0; i < NUM_PARAMS; i++) { + for (Index i = 0; i < numParams; i++) { thunkParams.push_back(Type::i64); } - auto* thunkFunc = + auto thunkFunc = builder.makeFunction(thunk, Signature(Type(thunkParams), Type::i64), {}, // no vars toABI(call, module)); - module->addFunction(thunkFunc); + module->addFunction(std::move(thunkFunc)); return thunk; } }; diff --git a/binaryen/src/passes/GenerateDynCalls.cpp b/binaryen/src/passes/GenerateDynCalls.cpp --- a/binaryen/src/passes/GenerateDynCalls.cpp +++ b/binaryen/src/passes/GenerateDynCalls.cpp @@ -120,7 +120,7 @@ for (const auto& param : sig.params) { params.emplace_back(std::to_string(p++), param); } - Function* f = builder.makeFunction(name, std::move(params), sig.results, {}); + auto f = builder.makeFunction(name, std::move(params), sig.results, {}); Expression* fptr = builder.makeLocalGet(0, Type::i32); std::vector args; Index i = 0; @@ -130,8 +130,8 @@ Expression* call = builder.makeCallIndirect(fptr, args, sig); f->body = call; - wasm->addFunction(f); - exportFunction(*wasm, f->name, true); + wasm->addFunction(std::move(f)); + exportFunction(*wasm, name, true); } Pass* createGenerateDynCallsPass() { return new GenerateDynCalls(false); } diff --git a/binaryen/src/passes/I64ToI32Lowering.cpp b/binaryen/src/passes/I64ToI32Lowering.cpp --- a/binaryen/src/passes/I64ToI32Lowering.cpp +++ b/binaryen/src/passes/I64ToI32Lowering.cpp @@ -22,7 +22,6 @@ // #include "abi/js.h" -#include "asmjs/shared-constants.h" #include "emscripten-optimizer/istring.h" #include "ir/flat.h" #include "ir/iteration.h" @@ -114,11 +113,10 @@ } 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); + auto high = builder->makeGlobal(makeHighName(curr->name), + Type::i32, + builder->makeConst(int32_t(0)), + Builder::Mutable); if (curr->imported()) { Fatal() << "TODO: imported i64 globals"; } else { @@ -135,6 +133,7 @@ } curr->init->type = Type::i32; } + module->addGlobal(std::move(high)); } // For functions that return 64-bit values, we use this global variable @@ -219,6 +218,9 @@ // returns nullptr; template T* visitGenericCall(T* curr, BuilderFunc callBuilder) { + if (handleUnreachable(curr)) { + return nullptr; + } bool fixed = false; std::vector args; for (auto* e : curr->operands) { diff --git a/binaryen/src/passes/Inlining.cpp b/binaryen/src/passes/Inlining.cpp --- a/binaryen/src/passes/Inlining.cpp +++ b/binaryen/src/passes/Inlining.cpp @@ -17,8 +17,6 @@ // // 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 @@ -62,25 +60,21 @@ // 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 it's small enough that we always want to inline such things, do so. 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 it has one use, then inlining it would likely reduce code size, at + // least for reasonable function sizes. if (refs == 1 && !usedGlobally && size <= options.inlining.oneCallerInlineMaxSize) { return true; } + // If it's so big that we have no flexible options that could allow it, + // do not inline. + if (size > options.inlining.flexibleInlineMaxSize) { + return false; + } // 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 @@ -217,6 +211,12 @@ handleReturnCall(curr, curr->sig.results); } } + void visitCallRef(CallRef* curr) { + if (curr->isReturn) { + handleReturnCall(curr, + curr->target->type.getHeapType().getSignature().results); + } + } void visitLocalGet(LocalGet* curr) { curr->index = localMapping[curr->index]; } @@ -326,7 +326,6 @@ 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; @@ -336,6 +335,16 @@ for (auto name : segment.data) { infos[name].usedGlobally = true; } + } + for (auto& global : module->globals) { + if (!global->imported()) { + for (auto* ref : FindAll(global->init).list) { + infos[ref->func].usedGlobally = true; + } + } + } + if (module->start.is()) { + infos[module->start].usedGlobally = true; } } diff --git a/binaryen/src/passes/InstrumentLocals.cpp b/binaryen/src/passes/InstrumentLocals.cpp --- a/binaryen/src/passes/InstrumentLocals.cpp +++ b/binaryen/src/passes/InstrumentLocals.cpp @@ -43,7 +43,6 @@ // ) // ) -#include "asm_v_wasm.h" #include "asmjs/shared-constants.h" #include "shared-constants.h" #include @@ -135,8 +134,13 @@ Builder builder(*getModule()); Name import; + auto type = curr->value->type; + if (type.isFunction() && type != Type::funcref) { + // FIXME: support typed function references + return; + } TODO_SINGLE_COMPOUND(curr->value->type); - switch (curr->value->type.getBasic()) { + switch (type.getBasic()) { case Type::i32: import = set_i32; break; @@ -171,7 +175,7 @@ break; case Type::unreachable: return; // nothing to do here - case Type::none: + default: WASM_UNREACHABLE("unexpected type"); } curr->value = builder.makeCall(import, diff --git a/binaryen/src/passes/InstrumentMemory.cpp b/binaryen/src/passes/InstrumentMemory.cpp --- a/binaryen/src/passes/InstrumentMemory.cpp +++ b/binaryen/src/passes/InstrumentMemory.cpp @@ -52,7 +52,6 @@ // ) // ) -#include "asm_v_wasm.h" #include "asmjs/shared-constants.h" #include "shared-constants.h" #include diff --git a/binaryen/src/passes/LegalizeJSInterface.cpp b/binaryen/src/passes/LegalizeJSInterface.cpp --- a/binaryen/src/passes/LegalizeJSInterface.cpp +++ b/binaryen/src/passes/LegalizeJSInterface.cpp @@ -30,7 +30,6 @@ // 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" @@ -54,7 +53,7 @@ .getArgumentOrDefault("legalize-js-interface-export-originals", "") .empty(); // for each illegal export, we must export a legalized stub instead - std::vector newExports; + std::vector> newExports; for (auto& ex : module->exports) { if (ex->kind == ExternalKind::Function) { // if it's an import, ignore it @@ -82,8 +81,8 @@ } } } - for (auto* ex : newExports) { - module->addExport(ex); + for (auto& ex : newExports) { + module->addExport(std::move(ex)); } // Avoid iterator invalidation later. std::vector originalFunctions; diff --git a/binaryen/src/passes/LogExecution.cpp b/binaryen/src/passes/LogExecution.cpp --- a/binaryen/src/passes/LogExecution.cpp +++ b/binaryen/src/passes/LogExecution.cpp @@ -28,7 +28,6 @@ // value. // -#include "asm_v_wasm.h" #include "asmjs/shared-constants.h" #include "shared-constants.h" #include diff --git a/binaryen/src/passes/LoopInvariantCodeMotion.cpp b/binaryen/src/passes/LoopInvariantCodeMotion.cpp --- a/binaryen/src/passes/LoopInvariantCodeMotion.cpp +++ b/binaryen/src/passes/LoopInvariantCodeMotion.cpp @@ -114,17 +114,20 @@ } if (interestingToMove(curr)) { // Let's see if we can move this out. - // Global side effects would prevent this - we might end up + // Global state changes 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()); + bool unsafeToMove = + effects.writesGlobalState() || effectsSoFar.invalidates(effects) || + (effects.readsGlobalState() && loopEffects.writesGlobalState()); + // TODO: look into optimizing this with exceptions. for now, disallow + if (effects.throws || loopEffects.throws) { + unsafeToMove = true; + } if (!unsafeToMove) { // So far so good. Check if our local dependencies are all // outside of the loop, in which case everything is good - diff --git a/binaryen/src/passes/Memory64Lowering.cpp b/binaryen/src/passes/Memory64Lowering.cpp new file mode 100644 --- /dev/null +++ b/binaryen/src/passes/Memory64Lowering.cpp @@ -0,0 +1,101 @@ +/* + * 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. + */ + +// +// Lowers a module with loads and stores that access a 64-bit memory with +// one that works as-is on wasm32. +// +// TODO(wvo): make this run in parallel if needed. + +#include "ir/bits.h" +#include "pass.h" +#include "wasm-builder.h" +#include "wasm.h" + +namespace wasm { + +struct Memory64Lowering : public WalkerPass> { + + void run(PassRunner* runner, Module* module) override { + if (module->memory.is64()) { + super::run(runner, module); + } + } + + void wrapAddress64(Expression*& ptr) { + if (ptr->type == Type::unreachable) { + return; + } + auto& module = *getModule(); + assert(module.memory.is64()); + assert(ptr->type == Type::i64); + Builder builder(module); + ptr = builder.makeUnary(UnaryOp::WrapInt64, ptr); + } + + void extendAddress64(Expression*& ptr) { + if (ptr->type == Type::unreachable) { + return; + } + auto& module = *getModule(); + assert(module.memory.is64()); + assert(ptr->type == Type::i64); + ptr->type = Type::i32; + Builder builder(module); + ptr = builder.makeUnary(UnaryOp::ExtendUInt32, ptr); + } + + void visitLoad(Load* curr) { wrapAddress64(curr->ptr); } + + void visitStore(Store* curr) { wrapAddress64(curr->ptr); } + + void visitMemorySize(MemorySize* curr) { + auto size = static_cast(curr); + extendAddress64(size); + curr->ptrType = Type::i32; + replaceCurrent(size); + } + + void visitMemoryGrow(MemoryGrow* curr) { + wrapAddress64(curr->delta); + auto size = static_cast(curr); + extendAddress64(size); + curr->ptrType = Type::i32; + replaceCurrent(size); + } + + void visitMemoryInit(MemoryInit* curr) { wrapAddress64(curr->dest); } + + void visitMemoryFill(MemoryFill* curr) { + wrapAddress64(curr->dest); + wrapAddress64(curr->size); + } + + void visitMemoryCopy(MemoryCopy* curr) { + wrapAddress64(curr->dest); + wrapAddress64(curr->source); + wrapAddress64(curr->size); + } + + void visitMemory(Memory* memory) { + // This is visited last. + memory->indexType = Type::i32; + } +}; + +Pass* createMemory64LoweringPass() { return new Memory64Lowering(); } + +} // namespace wasm diff --git a/binaryen/src/passes/MemoryPacking.cpp b/binaryen/src/passes/MemoryPacking.cpp --- a/binaryen/src/passes/MemoryPacking.cpp +++ b/binaryen/src/passes/MemoryPacking.cpp @@ -30,14 +30,18 @@ #include "ir/manipulation.h" #include "ir/module-utils.h" +#include "ir/names.h" #include "ir/utils.h" #include "pass.h" +#include "support/space.h" #include "wasm-binary.h" #include "wasm-builder.h" #include "wasm.h" namespace wasm { +namespace { + // 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 { @@ -74,8 +78,6 @@ // 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( @@ -89,14 +91,13 @@ } // 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; + bool canOptimize(const Memory& memory, const PassOptions& passOptions); void optimizeBulkMemoryOps(PassRunner* runner, Module* module); void getSegmentReferrers(Module* module, std::vector& referrers); void dropUnusedSegments(std::vector& segments, @@ -121,13 +122,14 @@ }; void MemoryPacking::run(PassRunner* runner, Module* module) { - if (!module->memory.exists) { + if (!canOptimize(module->memory, runner->options)) { 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 @@ -154,6 +156,7 @@ auto& currReferrers = referrers[origIndex]; std::vector ranges; + if (canSplit(segment, currReferrers)) { calculateRanges(segment, currReferrers, ranges); } else { @@ -176,8 +179,88 @@ } } +bool MemoryPacking::canOptimize(const Memory& memory, + const PassOptions& passOptions) { + if (!memory.exists) { + return false; + } + + // We must optimize under the assumption that memory has been initialized to + // zero. That is the case for a memory declared in the module, but for a + // memory that is imported, we must be told that it is zero-initialized. + if (memory.imported() && !passOptions.zeroFilledMemory) { + return false; + } + + auto& segments = memory.segments; + + // One segment is always ok to optimize, as it does not have the potential + // problems handled below. + if (segments.size() <= 1) { + return true; + } + // Check if it is ok for us to optimize. + Address maxAddress = 0; + for (auto& segment : segments) { + if (!segment.isPassive) { + auto* c = segment.offset->dynCast(); + // If an active segment has a non-constant offset, then what gets written + // cannot be known until runtime. That is, the active segments are written + // out at startup, in order, and one may trample the data of another, like + // + // (data (i32.const 100) "a") + // (data (i32.const 100) "\00") + // + // It is *not* ok to optimize out the zero in the last segment, as it is + // actually needed, it will zero out the "a" that was written earlier. And + // if a segment has an imported offset, + // + // (data (i32.const 100) "a") + // (data (global.get $x) "\00") + // + // then we can't tell if that last segment will end up overwriting or not. + // The only case we can easily handle is if there is just a single + // segment, which we handled earlier. (Note that that includes the main + // case of having a non-constant offset, dynamic linking, in which we have + // a single segment.) + if (!c) { + return false; + } + // Note the maximum address so far. + maxAddress = std::max( + maxAddress, Address(c->value.getInteger() + segment.data.size())); + } + } + // All active segments have constant offsets, known at this time, so we may be + // able to optimize, but must still check for the trampling problem mentioned + // earlier. + // TODO: optimize in the trampling case + DisjointSpans space; + for (auto& segment : segments) { + if (!segment.isPassive) { + auto* c = segment.offset->cast(); + Address start = c->value.getInteger(); + DisjointSpans::Span span{start, start + segment.data.size()}; + if (space.addAndCheckOverlap(span)) { + std::cerr << "warning: active memory segments have overlap, which " + << "prevents some optimizations.\n"; + return false; + } + } + } + return true; +} + bool MemoryPacking::canSplit(const Memory::Segment& segment, const Referrers& referrers) { + // Don't mess with segments related to llvm coverage tools such as + // __llvm_covfun. There segments are expected/parsed by external downstream + // tools (llvm-cov) so they need to be left intact. + // See https://clang.llvm.org/docs/SourceBasedCodeCoverage.html + if (segment.name.is() && segment.name.startsWith("__llvm")) { + return false; + } + if (segment.isPassive) { for (auto* referrer : referrers) { if (auto* init = referrer->dynCast()) { @@ -188,10 +271,10 @@ } } return true; - } else { - // Active segments can only be split if they have constant offsets - return segment.offset->is(); } + + // Active segments can only be split if they have constant offsets + return segment.offset->is(); } void MemoryPacking::calculateRanges(const Memory::Segment& segment, @@ -431,6 +514,7 @@ std::vector& ranges, std::vector& packed, size_t segmentsRemaining) { + size_t segmentCount = 0; for (size_t i = 0; i < ranges.size(); ++i) { Range& range = ranges[i]; if (range.isZero) { @@ -454,7 +538,22 @@ range.end = lastNonzero->end; ranges.erase(ranges.begin() + i + 1, lastNonzero + 1); } - packed.emplace_back(segment.isPassive, + Name name; + if (segment.name.is()) { + // Name the first range after the original segment and all following + // ranges get numbered accordingly. This means that for segments that + // canot be split (segments that contains a single range) the input and + // output segment have the same name. + if (!segmentCount) { + name = segment.name; + } else { + name = std::string(segment.name.c_str()) + "." + + std::to_string(segmentCount); + } + segmentCount++; + } + packed.emplace_back(name, + segment.isPassive, offset, &segment.data[range.start], range.end - range.start); @@ -494,8 +593,8 @@ if (dropStateGlobal != Name()) { return dropStateGlobal; } - dropStateGlobal = Name(std::string("__mem_segment_drop_state_") + - std::to_string(dropStateGlobalCount++)); + dropStateGlobal = + Names::getValidGlobalName(*module, "__mem_segment_drop_state"); module->addGlobal(builder.makeGlobal(dropStateGlobal, Type::i32, builder.makeConst(int32_t(0)), @@ -514,10 +613,16 @@ size_t start = init->offset->cast()->value.geti32(); size_t end = start + init->size->cast()->value.geti32(); + // Segment index used in emitted memory.init instructions + size_t initIndex = segmentIndex; + // Index of the range from which this memory.init starts reading size_t firstRangeIdx = 0; while (firstRangeIdx < ranges.size() && ranges[firstRangeIdx].end <= start) { + if (!ranges[firstRangeIdx].isZero) { + ++initIndex; + } ++firstRangeIdx; } @@ -568,7 +673,6 @@ 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]; diff --git a/binaryen/src/passes/MergeBlocks.cpp b/binaryen/src/passes/MergeBlocks.cpp --- a/binaryen/src/passes/MergeBlocks.cpp +++ b/binaryen/src/passes/MergeBlocks.cpp @@ -564,7 +564,7 @@ void visitCall(Call* curr) { handleCall(curr); } - void visitCallIndirect(CallIndirect* curr) { + template void handleNonDirectCall(T* curr) { FeatureSet features = getModule()->features; Block* outer = nullptr; for (Index i = 0; i < curr->operands.size(); i++) { @@ -580,6 +580,10 @@ } optimize(curr, curr->target, outer); } + + void visitCallIndirect(CallIndirect* curr) { handleNonDirectCall(curr); } + + void visitCallRef(CallRef* curr) { handleNonDirectCall(curr); } void visitThrow(Throw* curr) { Block* outer = nullptr; diff --git a/binaryen/src/passes/OptimizeInstructions.cpp b/binaryen/src/passes/OptimizeInstructions.cpp --- a/binaryen/src/passes/OptimizeInstructions.cpp +++ b/binaryen/src/passes/OptimizeInstructions.cpp @@ -19,1938 +19,2439 @@ // #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(); } +#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) { + if (!type.isBasic()) { + return -1; + } + switch (type.getBasic()) { + case Type::i32: + return 32; + case Type::i64: + return 64; + default: + return -1; + } + } +}; + +namespace { +// perform some final optimizations +struct FinalOptimizer : public PostWalker { + const PassOptions& passOptions; + + FinalOptimizer(const PassOptions& passOptions) : passOptions(passOptions) {} + + void visitBinary(Binary* curr) { + if (auto* replacement = optimize(curr)) { + replaceCurrent(replacement); + } + } + + Binary* optimize(Binary* curr) { + using namespace Abstract; + using namespace Match; + { + Const* c; + if (matches(curr, binary(Add, any(), ival(&c)))) { + // normalize x + (-C) ==> x - C + if (c->value.isNegative()) { + c->value = c->value.neg(); + curr->op = Abstract::getBinary(c->type, Sub); + } + // 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). + int64_t value = c->value.getInteger(); + if (value == 0x40LL || value == 0x2000LL || value == 0x100000LL || + value == 0x8000000LL || value == 0x400000000LL || + value == 0x20000000000LL || value == 0x1000000000000LL || + value == 0x80000000000000LL || value == 0x4000000000000000LL) { + c->value = c->value.neg(); + if (curr->op == Abstract::getBinary(c->type, Add)) { + curr->op = Abstract::getBinary(c->type, Sub); + } else { + curr->op = Abstract::getBinary(c->type, Add); + } + } + return curr; + } + } + return nullptr; + } +}; + +} // anonymous namespace + +// 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); + { + FinalOptimizer optimizer(getPassOptions()); + optimizer.walkFunction(func); + } + } + + void visitExpression(Expression* curr) { + // 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->is() || curr->is() || curr->is() || + (curr->type == Type::unreachable && !curr->is() && + !curr->is() && !curr->is())) { + return; + } + // we may be able to apply multiple patterns, one may open opportunities + // that look deeper NB: patterns must not have cycles + while ((curr = handOptimize(curr))) { + replaceCurrent(curr); + } + } + + 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) { + if (curr->is()) { + return nullptr; + } + + FeatureSet features = getModule()->features; + + if (auto* binary = curr->dynCast()) { + if (shouldCanonicalize(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; + using namespace Abstract; + 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: + // (ival.add + // (ival.sub + // (ival.const 0) + // X + // ) + // Y + // ) + // => + // (ival.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(Add, binary(&sub, Sub, ival(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: + // (ival.add + // Y + // (ival.sub + // (ival.const 0) + // X + // ) + // ) + // => + // (ival.sub + // Y + // X + // ) + Expression* y; + Binary* sub; + if (matches(curr, + binary(Add, any(&y), binary(&sub, Sub, ival(0), any())))) { + sub->left = y; + return sub; + } + } + { + // eqz(x - y) => x == y + Binary* inner; + if (matches(curr, unary(EqZ, binary(&inner, Sub, any(), any())))) { + inner->op = Abstract::getBinary(inner->left->type, Eq); + inner->type = Type::i32; + return inner; + } + } + { + // eqz(x + C) => x == -C + Const* c; + Binary* inner; + if (matches(curr, unary(EqZ, binary(&inner, Add, any(), ival(&c))))) { + c->value = c->value.neg(); + inner->op = Abstract::getBinary(c->type, Eq); + inner->type = Type::i32; + return inner; + } + } + { + // eqz((signed)x % C_pot) => eqz(x & (abs(C_pot) - 1)) + Const* c; + Binary* inner; + if (matches(curr, unary(EqZ, binary(&inner, RemS, any(), ival(&c)))) && + (c->value.isSignedMin() || + Bits::isPowerOf2(c->value.abs().getInteger()))) { + inner->op = Abstract::getBinary(c->type, 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 + // x <<>> (y & (32 | 64)) ==> x + // 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(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; + } + // i32(x) <<>> (y & C) ==> x, where (C & 31) == 0 + // i64(x) <<>> (y & C) ==> x, where (C & 63) == 0 + if (((c->type == Type::i32 && (c->value.geti32() & 31) == 0) || + (c->type == Type::i64 && (c->value.geti64() & 63LL) == 0LL)) && + !effects(y).hasSideEffects()) { + return x; + } + } + } + { + // unsigned(x) >= 0 => i32(1) + Const* c; + Expression* x; + if (matches(curr, binary(GeU, pure(&x), ival(&c))) && + c->value.isZero()) { + c->value = Literal::makeOne(Type::i32); + c->type = Type::i32; + return c; + } + // unsigned(x) < 0 => i32(0) + if (matches(curr, binary(LtU, pure(&x), ival(&c))) && + c->value.isZero()) { + c->value = Literal::makeZero(Type::i32); + c->type = Type::i32; + return c; + } + } + } + + 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) { + assert(binary->type.isInteger()); + + uint64_t constant = 0; + std::vector constants; + + struct SeekState { + Expression* curr; + uint64_t mul; + SeekState(Expression* curr, uint64_t 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()) { + uint64_t value = c->value.getInteger(); + if (value != 0ULL) { + constant += value * mul; + constants.push_back(c); + } + continue; + } else if (auto* binary = curr->dynCast()) { + if (binary->op == Abstract::getBinary(binary->type, Abstract::Add)) { + seekStack.emplace_back(binary->right, mul); + seekStack.emplace_back(binary->left, mul); + continue; + } else if (binary->op == + Abstract::getBinary(binary->type, Abstract::Sub)) { + // 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.isZero()) { + seekStack.emplace_back(binary->left, mul); + } + continue; + } else if (binary->op == + Abstract::getBinary(binary->type, Abstract::Shl)) { + if (auto* c = binary->right->dynCast()) { + seekStack.emplace_back(binary->left, + mul << Bits::getEffectiveShifts(c)); + continue; + } + } else if (binary->op == + Abstract::getBinary(binary->type, Abstract::Mul)) { + if (auto* c = binary->left->dynCast()) { + seekStack.emplace_back(binary->right, + mul * (uint64_t)c->value.getInteger()); + continue; + } else if (auto* c = binary->right->dynCast()) { + seekStack.emplace_back(binary->left, + mul * (uint64_t)c->value.getInteger()); + 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.isZero()) { + return binary->left; + } + } + return nullptr; + } + // wipe out all constants, we'll replace with a single added one + for (auto* c : constants) { + c->value = Literal::makeZero(c->type); + } + // 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) { + if (!curr->type.isInteger()) { + return; + } + FeatureSet features = getModule()->features; + auto type = curr->type; + auto* left = curr->left->dynCast(); + auto* right = curr->right->dynCast(); + // Canonicalization prefers an add instead of a subtract wherever + // possible. That prevents a subtracted constant on the right, + // as it would be added. And for a zero on the left, it can't be + // removed (it is how we negate ints). + if (curr->op == Abstract::getBinary(type, Abstract::Add)) { + if (left && left->value.isZero()) { + replaceCurrent(curr->right); + return; + } + if (right && right->value.isZero()) { + replaceCurrent(curr->left); + return; + } + } else if (curr->op == Abstract::getBinary(type, Abstract::Shl)) { + // shifting a 0 is a 0, or anything by 0 has no effect, all unless the + // shift has side effects + if (((left && left->value.isZero()) || + (right && Bits::getEffectiveShifts(right) == 0)) && + !EffectAnalyzer(passOptions, features, curr->right) + .hasSideEffects()) { + replaceCurrent(curr->left); + return; + } + } else if (curr->op == Abstract::getBinary(type, Abstract::Mul)) { + // multiplying by zero is a zero, unless the other side has side + // effects + if (left && left->value.isZero() && + !EffectAnalyzer(passOptions, features, curr->right) + .hasSideEffects()) { + replaceCurrent(left); + return; + } + if (right && right->value.isZero() && + !EffectAnalyzer(passOptions, features, curr->left) + .hasSideEffects()) { + replaceCurrent(right); + return; + } + } + } + }; + Expression* walked = binary; + ZeroRemover remover(getPassOptions()); + remover.setModule(getModule()); + remover.walk(walked); + if (constant == 0ULL) { + return walked; // nothing more to do + } + if (auto* c = walked->dynCast()) { + assert(c->value.isZero()); + // Accumulated 64-bit constant value in 32-bit context will be wrapped + // during downcasting. So it's valid unification for 32-bit and 64-bit + // values. + c->value = Literal::makeFromInt64(constant, c->type); + return c; + } + Builder builder(*getModule()); + return builder.makeBinary( + Abstract::getBinary(walked->type, Abstract::Add), + walked, + builder.makeConst(Literal::makeFromInt64(constant, walked->type))); + } + + // 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* 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; + } + + 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* optimizePowerOf2FDiv(Binary* binary, T c) { + // + // x / C_pot => x * (C_pot ^ -1) + // + // Explanation: + // Floating point numbers are represented as: + // ((-1) ^ sign) * (2 ^ (exp - bias)) * (1 + significand) + // + // If we have power of two numbers, then the mantissa (significand) + // is all zeros. Let's focus on the exponent, ignoring the sign part: + // (2 ^ (exp - bias)) + // + // and for inverted power of two floating point: + // 1.0 / (2 ^ (exp - bias)) -> 2 ^ -(exp - bias) + // + // So inversion of C_pot is valid because it changes only the sign + // of the exponent part and doesn't touch the significand part, + // which remains the same (zeros). + static_assert(std::is_same::value || + std::is_same::value, + "type mismatch"); + double invDivisor = 1.0 / (double)c; + binary->op = std::is_same::value ? MulFloat32 : MulFloat64; + binary->right->cast()->value = Literal(static_cast(invDivisor)); + 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; + using namespace Abstract; + Builder builder(*getModule()); + Expression* left; + auto* right = curr->right->cast(); + auto type = curr->right->type; + + // Operations on zero + if (matches(curr, binary(Shl, any(&left), ival(0))) || + matches(curr, binary(ShrU, any(&left), ival(0))) || + matches(curr, binary(ShrS, any(&left), ival(0))) || + matches(curr, binary(Or, any(&left), ival(0))) || + matches(curr, binary(Xor, any(&left), ival(0)))) { + return left; + } + if (matches(curr, binary(Mul, pure(&left), ival(0))) || + matches(curr, binary(And, pure(&left), ival(0)))) { + return right; + } + // x == 0 ==> eqz x + if (matches(curr, binary(Eq, any(&left), ival(0)))) { + return builder.makeUnary(Abstract::getUnary(type, EqZ), left); + } + // Operations on one + // (signed)x % 1 ==> 0 + if (matches(curr, binary(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(Ne, binary(&inner, RemS, any(), ival(&c)), ival(0))) && + (c->value.isSignedMin() || + Bits::isPowerOf2(c->value.abs().getInteger()))) { + inner->op = Abstract::getBinary(c->type, And); + if (c->value.isSignedMin()) { + c->value = Literal::makeSignedMax(c->type); + } else { + c->value = c->value.abs().sub(Literal::makeOne(c->type)); + } + return curr; + } + } + // i32(bool(x)) == 1 ==> i32(bool(x)) + // i32(bool(x)) != 0 ==> i32(bool(x)) + // i32(bool(x)) & 1 ==> i32(bool(x)) + // i64(bool(x)) & 1 ==> i64(bool(x)) + if ((matches(curr, binary(EqInt32, any(&left), i32(1))) || + matches(curr, binary(NeInt32, any(&left), i32(0))) || + matches(curr, binary(And, any(&left), ival(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(Ne, any(&left), ival(1))) && + Bits::getMaxBits(left, this) == 1) { + return builder.makeUnary(Abstract::getUnary(type, EqZ), left); + } + // bool(x) | 1 ==> 1 + if (matches(curr, binary(Or, pure(&left), ival(1))) && + Bits::getMaxBits(left, this) == 1) { + return right; + } + + // Operations on all 1s + // x & -1 ==> x + if (matches(curr, binary(And, any(&left), ival(-1)))) { + return left; + } + // x | -1 ==> -1 + if (matches(curr, binary(Or, pure(&left), ival(-1)))) { + return right; + } + // (signed)x % -1 ==> 0 + if (matches(curr, binary(RemS, pure(&left), ival(-1)))) { + right->value = Literal::makeZero(type); + return right; + } + // i32(x) / i32.min_s ==> x == i32.min_s + if (matches( + curr, + binary(DivSInt32, any(), i32(std::numeric_limits::min())))) { + curr->op = EqInt32; + return curr; + } + // i64(x) / i64.min_s ==> i64(x == i64.min_s) + // only for zero shrink level + if (getPassOptions().shrinkLevel == 0 && + matches( + curr, + binary(DivSInt64, any(), i64(std::numeric_limits::min())))) { + curr->op = EqInt64; + curr->type = Type::i32; + return Builder(*getModule()).makeUnary(ExtendUInt32, curr); + } + // (unsigned)x < 0 ==> i32(0) + if (matches(curr, binary(LtU, pure(&left), ival(0)))) { + right->value = Literal::makeZero(Type::i32); + right->type = Type::i32; + return right; + } + // (unsigned)x <= -1 ==> i32(1) + if (matches(curr, binary(LeU, pure(&left), ival(-1)))) { + right->value = Literal::makeOne(Type::i32); + right->type = Type::i32; + return right; + } + // (unsigned)x > -1 ==> i32(0) + if (matches(curr, binary(GtU, pure(&left), ival(-1)))) { + right->value = Literal::makeZero(Type::i32); + right->type = Type::i32; + return right; + } + // (unsigned)x >= 0 ==> i32(1) + if (matches(curr, binary(GeU, pure(&left), ival(0)))) { + right->value = Literal::makeOne(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(LtU, any(), ival(-1)))) { + curr->op = Abstract::getBinary(type, Ne); + return curr; + } + // (unsigned)x <= 0 ==> x == 0 + if (matches(curr, binary(LeU, any(), ival(0)))) { + curr->op = Abstract::getBinary(type, Eq); + return curr; + } + // (unsigned)x > 0 ==> x != 0 + if (matches(curr, binary(GtU, any(), ival(0)))) { + curr->op = Abstract::getBinary(type, Ne); + return curr; + } + // (unsigned)x >= -1 ==> x == -1 + if (matches(curr, binary(GeU, any(), ival(-1)))) { + curr->op = Abstract::getBinary(type, Eq); + return curr; + } + { + Const* c; + // (signed)x < (i32|i64).min_s ==> i32(0) + if (matches(curr, binary(LtS, pure(&left), ival(&c))) && + c->value.isSignedMin()) { + right->value = Literal::makeZero(Type::i32); + right->type = Type::i32; + return right; + } + // (signed)x <= (i32|i64).max_s ==> i32(1) + if (matches(curr, binary(LeS, pure(&left), ival(&c))) && + c->value.isSignedMax()) { + right->value = Literal::makeOne(Type::i32); + right->type = Type::i32; + return right; + } + // (signed)x > (i32|i64).max_s ==> i32(0) + if (matches(curr, binary(GtS, pure(&left), ival(&c))) && + c->value.isSignedMax()) { + right->value = Literal::makeZero(Type::i32); + right->type = Type::i32; + return right; + } + // (signed)x >= (i32|i64).min_s ==> i32(1) + if (matches(curr, binary(GeS, pure(&left), ival(&c))) && + c->value.isSignedMin()) { + right->value = Literal::makeOne(Type::i32); + right->type = Type::i32; + return right; + } + // (signed)x < (i32|i64).max_s ==> x != (i32|i64).max_s + if (matches(curr, binary(LtS, any(), ival(&c))) && + c->value.isSignedMax()) { + curr->op = Abstract::getBinary(type, Ne); + return curr; + } + // (signed)x <= (i32|i64).min_s ==> x == (i32|i64).min_s + if (matches(curr, binary(LeS, any(), ival(&c))) && + c->value.isSignedMin()) { + curr->op = Abstract::getBinary(type, Eq); + return curr; + } + // (signed)x > (i32|i64).min_s ==> x != (i32|i64).min_s + if (matches(curr, binary(GtS, any(), ival(&c))) && + c->value.isSignedMin()) { + curr->op = Abstract::getBinary(type, Ne); + return curr; + } + // (signed)x >= (i32|i64).max_s ==> x == (i32|i64).max_s + if (matches(curr, binary(GeS, any(), ival(&c))) && + c->value.isSignedMax()) { + curr->op = Abstract::getBinary(type, Eq); + return curr; + } + } + // x * -1 ==> 0 - x + if (matches(curr, binary(Mul, any(&left), ival(-1)))) { + right->value = Literal::makeZero(type); + curr->op = Abstract::getBinary(type, Sub); + curr->left = right; + curr->right = left; + return curr; + } + { + // ~(1 << x) aka (1 << x) ^ -1 ==> rotl(-2, x) + Expression* x; + if (matches(curr, binary(Xor, binary(Shl, ival(1), any(&x)), ival(-1)))) { + curr->op = Abstract::getBinary(type, RotL); + right->value = Literal::makeFromInt32(-2, type); + curr->left = right; + curr->right = x; + return curr; + } + } + { + double value; + if (matches(curr, binary(Sub, any(), fval(&value))) && value == 0.0) { + // x - (-0.0) ==> x + 0.0 + if (std::signbit(value)) { + curr->op = Abstract::getBinary(type, Add); + right->value = right->value.neg(); + return curr; + } else if (fastMath) { + // x - 0.0 ==> x + return curr->left; + } + } + } + { + // x * 2.0 ==> x + x + // but we apply this only for simple expressions like + // local.get and global.get for avoid using extra local + // variable. + Expression* x; + if (matches(curr, binary(Mul, any(&x), fval(2.0))) && + (x->is() || x->is())) { + curr->op = Abstract::getBinary(type, Abstract::Add); + curr->right = ExpressionManipulator::copy(x, *getModule()); + return curr; + } + } + { + // x + (-0.0) ==> x + double value; + if (fastMath && matches(curr, binary(Add, any(), fval(&value))) && + value == 0.0 && std::signbit(value)) { + return curr->left; + } + } + // -x * fval(C) ==> x * -C + // -x / fval(C) ==> x / -C + if (matches(curr, binary(Mul, unary(Neg, any(&left)), fval())) || + matches(curr, binary(DivS, unary(Neg, any(&left)), fval()))) { + right->value = right->value.neg(); + curr->left = left; + return curr; + } + // x * -1.0 ==> + // -x, if fastMath == true + // -0.0 - x, if fastMath == false + if (matches(curr, binary(Mul, any(), fval(-1.0)))) { + if (fastMath) { + return builder.makeUnary(Abstract::getUnary(type, Neg), left); + } + // x * -1.0 ==> -0.0 - x + curr->op = Abstract::getBinary(type, Sub); + right->value = Literal::makeZero(type).neg(); + std::swap(curr->left, curr->right); + return curr; + } + if (matches(curr, binary(Mul, any(&left), constant(1))) || + matches(curr, binary(DivS, any(&left), constant(1))) || + matches(curr, binary(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* curr) { + using namespace Match; + using namespace Abstract; + + auto type = curr->left->type; + auto* left = curr->left->cast(); + // 0 <<>> x ==> 0 + if (Abstract::hasAnyShift(curr->op) && left->value.isZero() && + !effects(curr->right).hasSideEffects()) { + return curr->left; + } + // (signed)-1 >> x ==> -1 + // rotl(-1, x) ==> -1 + // rotr(-1, x) ==> -1 + if ((curr->op == Abstract::getBinary(type, ShrS) || + curr->op == Abstract::getBinary(type, RotL) || + curr->op == Abstract::getBinary(type, RotR)) && + left->value.getInteger() == -1LL && + !effects(curr->right).hasSideEffects()) { + return curr->left; + } + { + // C1 - (x + C2) ==> (C1 - C2) - x + Const *c1, *c2; + Expression* x; + if (matches(curr, + binary(Sub, ival(&c1), binary(Add, any(&x), ival(&c2))))) { + left->value = c1->value.sub(c2->value); + curr->right = x; + return curr; + } + // C1 - (C2 - x) ==> x + (C1 - C2) + if (matches(curr, + binary(Sub, ival(&c1), binary(Sub, ival(&c2), any(&x))))) { + left->value = c1->value.sub(c2->value); + curr->op = Abstract::getBinary(type, Add); + curr->right = x; + std::swap(curr->left, curr->right); + return curr; + } + } + { + // fval(C) / -x ==> -C / x + Expression* right; + if (matches(curr, binary(DivS, fval(), unary(Neg, any(&right))))) { + left->value = left->value.neg(); + curr->right = right; + return curr; + } + } + return nullptr; + } + + // TODO: templatize on type? + Expression* optimizeRelational(Binary* curr) { + auto type = curr->right->type; + if (curr->left->type.isInteger()) { + if (curr->op == Abstract::getBinary(type, Abstract::Eq) || + curr->op == Abstract::getBinary(type, Abstract::Ne)) { + if (auto* left = curr->left->dynCast()) { + // TODO: inequalities can also work, if the constants do not overflow + // integer math, even on 2s complement, allows stuff like + // x + 5 == 7 + // => + // x == 2 + if (left->op == Abstract::getBinary(type, Abstract::Add)) { + if (auto* leftConst = left->right->dynCast()) { + if (auto* rightConst = curr->right->dynCast()) { + return combineRelationalConstants( + curr, left, leftConst, nullptr, rightConst); + } else if (auto* rightBinary = curr->right->dynCast()) { + if (rightBinary->op == + Abstract::getBinary(type, Abstract::Add)) { + if (auto* rightConst = rightBinary->right->dynCast()) { + return combineRelationalConstants( + curr, left, leftConst, rightBinary, rightConst); + } + } + } + } + } + } + } + // x - y == 0 => x == y + // x - y != 0 => x != y + // unsigned(x - y) > 0 => x != y + // unsigned(x - y) <= 0 => x == y + { + using namespace Abstract; + using namespace Match; + + Binary* inner; + // unsigned(x - y) > 0 => x != y + if (matches(curr, + binary(GtU, binary(&inner, Sub, any(), any()), ival(0)))) { + curr->op = Abstract::getBinary(type, Ne); + curr->right = inner->right; + curr->left = inner->left; + return curr; + } + // unsigned(x - y) <= 0 => x == y + if (matches(curr, + binary(LeU, binary(&inner, Sub, any(), any()), ival(0)))) { + curr->op = Abstract::getBinary(type, Eq); + curr->right = inner->right; + curr->left = inner->left; + return curr; + } + // x - y == 0 => x == y + // x - y != 0 => x != y + // This is not true for signed comparisons like x -y < 0 due to overflow + // effects (e.g. 8 - 0x80000000 < 0 is not the same as 8 < 0x80000000). + if (matches(curr, + binary(Eq, binary(&inner, Sub, any(), any()), ival(0))) || + matches(curr, + binary(Ne, binary(&inner, Sub, any(), any()), ival(0)))) { + curr->right = inner->right; + curr->left = inner->left; + return curr; + } + } + } + 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 reverseRelationalOp(BinaryOp op) { + switch (op) { + case EqInt32: + return EqInt32; + case NeInt32: + return NeInt32; + case LtSInt32: + return GtSInt32; + case LtUInt32: + return GtUInt32; + case LeSInt32: + return GeSInt32; + case LeUInt32: + return GeUInt32; + case GtSInt32: + return LtSInt32; + case GtUInt32: + return LtUInt32; + case GeSInt32: + return LeSInt32; + case GeUInt32: + return LeUInt32; + + case EqInt64: + return EqInt64; + case NeInt64: + return NeInt64; + case LtSInt64: + return GtSInt64; + case LtUInt64: + return GtUInt64; + case LeSInt64: + return GeSInt64; + case LeUInt64: + return GeUInt64; + case GtSInt64: + return LtSInt64; + case GtUInt64: + return LtUInt64; + case GeSInt64: + return LeSInt64; + case GeUInt64: + return LeUInt64; + + case EqFloat32: + return EqFloat32; + case NeFloat32: + return NeFloat32; + case LtFloat32: + return GtFloat32; + case LeFloat32: + return GeFloat32; + case GtFloat32: + return LtFloat32; + case GeFloat32: + return LeFloat32; + + case EqFloat64: + return EqFloat64; + case NeFloat64: + return NeFloat64; + case LtFloat64: + return GtFloat64; + case LeFloat64: + return GeFloat64; + case GtFloat64: + return LtFloat64; + case GeFloat64: + return LeFloat64; + + 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 shouldCanonicalize(Binary* binary) { + if ((binary->op == SubInt32 || binary->op == SubInt64) && + binary->right->is() && !binary->left->is()) { + return true; + } + if (Properties::isSymmetric(binary) || binary->isRelational()) { + 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 --- a/binaryen/src/passes/PickLoadSigns.cpp +++ b/binaryen/src/passes/PickLoadSigns.cpp @@ -109,6 +109,10 @@ load->bytes * 8)) { // unsigned usages exist but the wrong size continue; } + // Atomic operations are always unsigned, never signed. + if (load->isAtomic) { + 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; diff --git a/binaryen/src/passes/PostAssemblyScript.cpp b/binaryen/src/passes/PostAssemblyScript.cpp --- a/binaryen/src/passes/PostAssemblyScript.cpp +++ b/binaryen/src/passes/PostAssemblyScript.cpp @@ -28,7 +28,6 @@ #include #include #ifdef POST_ASSEMBLYSCRIPT_DEBUG -#include "wasm-printing.h" #include #endif @@ -468,14 +467,14 @@ if (allBalanced) { #ifdef POST_ASSEMBLYSCRIPT_DEBUG std::cerr << " eliminating "; - WasmPrinter::printExpression(retain, std::cerr, true); + std::cerr << *retain << '\n'; 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 << **getLocation << '\n'; std::cerr << "\n"; #endif redundantReleases.insert(getLocation); @@ -483,28 +482,28 @@ #ifdef POST_ASSEMBLYSCRIPT_DEBUG } else { std::cerr << " cannot eliminate "; - WasmPrinter::printExpression(retain, std::cerr, true); + std::cerr << *retain << '\n'; std::cerr << " - unbalanced\n"; #endif } #ifdef POST_ASSEMBLYSCRIPT_DEBUG } else { std::cerr << " cannot eliminate "; - WasmPrinter::printExpression(retain, std::cerr, true); + std::cerr << *retain << '\n'; std::cerr << " - zero releases\n"; #endif } #ifdef POST_ASSEMBLYSCRIPT_DEBUG } else { std::cerr << " cannot eliminate "; - WasmPrinter::printExpression(retain, std::cerr, true); + std::cerr << *retain << '\n'; std::cerr << " - retains allocation\n"; #endif } #ifdef POST_ASSEMBLYSCRIPT_DEBUG } else { std::cerr << " cannot eliminate "; - WasmPrinter::printExpression(retain, std::cerr, true); + std::cerr << *retain << '\n'; std::cerr << " - reaches return\n"; #endif } @@ -560,7 +559,7 @@ // __release(__retain(__alloc(...))) - unnecessary allocation #ifdef POST_ASSEMBLYSCRIPT_DEBUG std::cerr << " finalizing "; - WasmPrinter::printExpression(curr, std::cerr, true); + std::cerr << *curr << '\n'; std::cerr << " - unnecessary allocation\n"; #endif Builder builder(*getModule()); @@ -574,7 +573,7 @@ // __release(__retain(...)) - unnecessary pair #ifdef POST_ASSEMBLYSCRIPT_DEBUG std::cerr << " finalizing "; - WasmPrinter::printExpression(curr, std::cerr, true); + std::cerr << *curr << '\n'; std::cerr << " - unnecessary pair\n"; #endif Builder builder(*getModule()); @@ -586,7 +585,7 @@ // __release(42) - unnecessary static release #ifdef POST_ASSEMBLYSCRIPT_DEBUG std::cerr << " finalizing "; - WasmPrinter::printExpression(curr, std::cerr, true); + std::cerr << *curr << '\n'; std::cerr << " - static release\n"; #endif Builder builder(*getModule()); @@ -598,7 +597,7 @@ // __retain(42) - unnecessary static retain #ifdef POST_ASSEMBLYSCRIPT_DEBUG std::cerr << " finalizing "; - WasmPrinter::printExpression(curr, std::cerr, true); + std::cerr << *curr << '\n'; std::cerr << " - static retain\n"; #endif replaceCurrent(retainedConst); diff --git a/binaryen/src/passes/PostEmscripten.cpp b/binaryen/src/passes/PostEmscripten.cpp --- a/binaryen/src/passes/PostEmscripten.cpp +++ b/binaryen/src/passes/PostEmscripten.cpp @@ -41,46 +41,10 @@ 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); } @@ -122,12 +86,12 @@ } }); - // Assume an indirect call might throw. + // Assume a non-direct 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); + analyzer.NonDirectCallsHaveProperty); // Apply the information. struct OptimizeInvokes : public WalkerPass> { diff --git a/binaryen/src/passes/Precompute.cpp b/binaryen/src/passes/Precompute.cpp --- a/binaryen/src/passes/Precompute.cpp +++ b/binaryen/src/passes/Precompute.cpp @@ -177,6 +177,9 @@ if (flow.breakTo == NONCONSTANT_FLOW) { return; } + if (!canEmitConstantFor(flow.values)) { + return; + } if (flow.breakTo == RETURN_FLOW) { // this expression causes a return. if it's already a return, reuse the // node @@ -223,6 +226,9 @@ // 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) { + if (!canEmitConstantFor(curr->type)) { + return Flow(NONCONSTANT_FLOW); + } try { return PrecomputingExpressionRunner( getModule(), getValues, replaceExpression) @@ -337,6 +343,37 @@ } } } + } + + bool canEmitConstantFor(const Literals& values) { + for (auto& value : values) { + if (!canEmitConstantFor(value)) { + return false; + } + } + return true; + } + + bool canEmitConstantFor(const Literal& value) { + // A null is fine to emit a constant for - we'll emit a RefNull. Otherwise, + // see below about references to GC data. + if (value.isNull()) { + return true; + } + // A function is fine to emit a constant for - we'll emit a RefFunc, which + // is compact and immutable, so there can't be a problem. + if (value.type.isFunction()) { + return true; + } + return canEmitConstantFor(value.type); + } + + bool canEmitConstantFor(Type type) { + // Don't try to precompute a reference. We can't replace it with a constant + // expression, as that would make a copy of it by value. + // For now, don't try to precompute an Rtt. TODO figure out when that would + // be safe and useful. + return !type.isRef() && !type.isRtt(); } }; diff --git a/binaryen/src/passes/Print.cpp b/binaryen/src/passes/Print.cpp --- a/binaryen/src/passes/Print.cpp +++ b/binaryen/src/passes/Print.cpp @@ -21,12 +21,22 @@ #include #include #include -#include #include #include namespace wasm { +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 { bool isFullForced() { @@ -57,6 +67,101 @@ return printName(name, o); } +static void +printHeapTypeName(std::ostream& os, HeapType type, bool first = true); + +// Prints the name of a type. This output is guaranteed to not contain spaces. +static void printTypeName(std::ostream& os, Type type) { + if (type.isBasic()) { + os << type; + return; + } + if (type.isRtt()) { + auto rtt = type.getRtt(); + os << "rtt_"; + if (rtt.hasDepth()) { + os << rtt.depth << '_'; + } + printHeapTypeName(os, rtt.heapType); + return; + } + if (type.isTuple()) { + auto sep = ""; + for (auto t : type) { + os << sep; + sep = "_"; + printTypeName(os, t); + } + return; + } + if (type.isRef()) { + os << "ref"; + if (type.isNullable()) { + os << "?"; + } + os << "|"; + printHeapTypeName(os, type.getHeapType(), false); + os << "|"; + return; + } + WASM_UNREACHABLE("unsupported print type"); +} + +static void printFieldName(std::ostream& os, const Field& field) { + if (field.mutable_) { + os << "mut:"; + } + if (field.type == Type::i32 && field.packedType != Field::not_packed) { + if (field.packedType == Field::i8) { + os << "i8"; + } else if (field.packedType == Field::i16) { + os << "i16"; + } else { + WASM_UNREACHABLE("invalid packed type"); + } + } else { + printTypeName(os, field.type); + } +} + +// Prints the name of a heap type. As with printTypeName, this output is +// guaranteed to not contain spaces. +static void printHeapTypeName(std::ostream& os, HeapType type, bool first) { + if (type.isBasic()) { + os << type; + return; + } + if (first) { + os << '$'; + } + if (type.isSignature()) { + auto sig = type.getSignature(); + printTypeName(os, sig.params); + if (first) { + os << "_=>_"; + } else { + os << "_->_"; + } + printTypeName(os, sig.results); + } else if (type.isStruct()) { + auto struct_ = type.getStruct(); + os << "{"; + auto sep = ""; + for (auto& field : struct_.fields) { + os << sep; + sep = "_"; + printFieldName(os, field); + } + os << "}"; + } else if (type.isArray()) { + os << "["; + printFieldName(os, type.getArray().element); + os << "]"; + } else { + os << type; + } +} + // Unlike the default format, tuple types in s-expressions should not have // commas. struct SExprType { @@ -64,8 +169,8 @@ SExprType(Type type) : type(type){}; }; -static std::ostream& operator<<(std::ostream& o, const SExprType& localType) { - Type type = localType.type; +static std::ostream& operator<<(std::ostream& o, const SExprType& sType) { + Type type = sType.type; if (type.isTuple()) { o << '('; auto sep = ""; @@ -74,35 +179,50 @@ sep = " "; } o << ')'; + } else if (type.isRtt()) { + auto rtt = type.getRtt(); + o << "(rtt "; + if (rtt.hasDepth()) { + o << rtt.depth << ' '; + } + printHeapTypeName(o, rtt.heapType); + o << ')'; + } else if (type.isRef() && !type.isBasic()) { + o << "(ref "; + if (type.isNullable()) { + o << "null "; + } + printHeapTypeName(o, type.getHeapType()); + o << ')'; } else { - o << type; + printTypeName(o, sType.type); } return o; } -// Wrapper for printing signature names -struct SigName { - Signature sig; - SigName(Signature sig) : sig(sig) {} +// TODO: try to simplify or even remove this, as we may be able to do the same +// things with SExprType +struct ResultTypeName { + Type type; + ResultTypeName(Type type) : type(type) {} }; -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 = "_"; - } +std::ostream& operator<<(std::ostream& os, ResultTypeName typeName) { + auto type = typeName.type; + os << "(result "; + if (type.isTuple()) { + // Tuple types are not printed in parens, we can just emit them one after + // the other in the same list as the "result". + auto sep = ""; + for (auto t : type) { + os << sep; + sep = " "; + os << SExprType(t); } - }; - - os << '$'; - printType(sigName.sig.params); - os << "_=>_"; - printType(sigName.sig.results); + } else { + os << SExprType(type); + } + os << ')'; return os; } @@ -131,13 +251,13 @@ printName(curr->name, o); } if (curr->type.isConcrete()) { - o << ' ' << ResultType(curr->type); + o << ' ' << ResultTypeName(curr->type); } } void visitIf(If* curr) { printMedium(o, "if"); if (curr->type.isConcrete()) { - o << ' ' << ResultType(curr->type); + o << ' ' << ResultTypeName(curr->type); } } void visitLoop(Loop* curr) { @@ -147,7 +267,7 @@ printName(curr->name, o); } if (curr->type.isConcrete()) { - o << ' ' << ResultType(curr->type); + o << ' ' << ResultTypeName(curr->type); } } void visitBreak(Break* curr) { @@ -181,7 +301,8 @@ } else { printMedium(o, "call_indirect (type "); } - o << SigName(curr->sig) << ')'; + printHeapTypeName(o, curr->sig); + o << ')'; } void visitLocalGet(LocalGet* curr) { printMedium(o, "local.get "); @@ -274,22 +395,22 @@ prepareColor(o); printRMWSize(o, curr->type, curr->bytes); switch (curr->op) { - case Add: + case RMWAdd: o << "add"; break; - case Sub: + case RMWSub: o << "sub"; break; - case And: + case RMWAnd: o << "and"; break; - case Or: + case RMWOr: o << "or"; break; - case Xor: + case RMWXor: o << "xor"; break; - case Xchg: + case RMWXchg: o << "xchg"; break; } @@ -317,13 +438,15 @@ } void visitAtomicWait(AtomicWait* curr) { prepareColor(o); - o << forceConcrete(curr->expectedType) << ".atomic.wait"; + Type type = forceConcrete(curr->expectedType); + assert(type == Type::i32 || type == Type::i64); + o << "memory.atomic.wait" << (type == Type::i32 ? "32" : "64"); if (curr->offset) { o << " offset=" << curr->offset; } } void visitAtomicNotify(AtomicNotify* curr) { - printMedium(o, "atomic.notify"); + printMedium(o, "memory.atomic.notify"); if (curr->offset) { o << " offset=" << curr->offset; } @@ -408,6 +531,18 @@ case QFMSF64x2: o << "f64x2.qfms"; break; + case SignSelectVec8x16: + o << "v8x16.signselect"; + break; + case SignSelectVec16x8: + o << "v16x8.signselect"; + break; + case SignSelectVec32x4: + o << "v32x4.signselect"; + break; + case SignSelectVec64x2: + o << "v64x2.signselect"; + break; } } void visitSIMDShift(SIMDShift* curr) { @@ -499,6 +634,61 @@ o << " align=" << curr->align; } } + void visitSIMDLoadStoreLane(SIMDLoadStoreLane* curr) { + prepareColor(o); + switch (curr->op) { + case LoadLaneVec8x16: + o << "v128.load8_lane"; + break; + case LoadLaneVec16x8: + o << "v128.load16_lane"; + break; + case LoadLaneVec32x4: + o << "v128.load32_lane"; + break; + case LoadLaneVec64x2: + o << "v128.load64_lane"; + break; + case StoreLaneVec8x16: + o << "v128.store8_lane"; + break; + case StoreLaneVec16x8: + o << "v128.store16_lane"; + break; + case StoreLaneVec32x4: + o << "v128.store32_lane"; + break; + case StoreLaneVec64x2: + o << "v128.store64_lane"; + break; + } + restoreNormalColor(o); + if (curr->offset) { + o << " offset=" << curr->offset; + } + if (curr->align != curr->getMemBytes()) { + o << " align=" << curr->align; + } + o << " " << int(curr->index); + } + void visitPrefetch(Prefetch* curr) { + prepareColor(o); + switch (curr->op) { + case PrefetchTemporal: + o << "prefetch.t"; + break; + case PrefetchNontemporal: + o << "prefetch.nt"; + break; + } + restoreNormalColor(o); + if (curr->offset) { + o << " offset=" << curr->offset; + } + if (curr->align != 1) { + o << " align=" << curr->align; + } + } void visitMemoryInit(MemoryInit* curr) { prepareColor(o); o << "memory.init " << curr->segment; @@ -737,6 +927,9 @@ case BitmaskVecI8x16: o << "i8x16.bitmask"; break; + case PopcntVecI8x16: + o << "i8x16.popcnt"; + break; case AbsVecI16x8: o << "i16x8.abs"; break; @@ -770,11 +963,8 @@ case NegVecI64x2: o << "i64x2.neg"; break; - case AnyTrueVecI64x2: - o << "i64x2.any_true"; - break; - case AllTrueVecI64x2: - o << "i64x2.all_true"; + case BitmaskVecI64x2: + o << "i64x2.bitmask"; break; case AbsVecF32x4: o << "f32x4.abs"; @@ -818,6 +1008,18 @@ case NearestVecF64x2: o << "f64x2.nearest"; break; + case ExtAddPairwiseSVecI8x16ToI16x8: + o << "i16x8.extadd_pairwise_i8x16_s"; + break; + case ExtAddPairwiseUVecI8x16ToI16x8: + o << "i16x8.extadd_pairwise_i8x16_u"; + break; + case ExtAddPairwiseSVecI16x8ToI32x4: + o << "i32x4.extadd_pairwise_i16x8_s"; + break; + case ExtAddPairwiseUVecI16x8ToI32x4: + o << "i32x4.extadd_pairwise_i16x8_u"; + break; case TruncSatSVecF32x4ToVecI32x4: o << "i32x4.trunc_sat_f32x4_s"; break; @@ -866,6 +1068,18 @@ case WidenHighUVecI16x8ToVecI32x4: o << "i32x4.widen_high_i16x8_u"; break; + case WidenLowSVecI32x4ToVecI64x2: + o << "i64x2.widen_low_i32x4_s"; + break; + case WidenHighSVecI32x4ToVecI64x2: + o << "i64x2.widen_high_i32x4_s"; + break; + case WidenLowUVecI32x4ToVecI64x2: + o << "i64x2.widen_low_i32x4_u"; + break; + case WidenHighUVecI32x4ToVecI64x2: + o << "i64x2.widen_high_i32x4_u"; + break; case InvalidUnary: WASM_UNREACHABLE("unvalid unary operator"); } @@ -1195,6 +1409,9 @@ case GeUVecI32x4: o << "i32x4.ge_u"; break; + case EqVecI64x2: + o << "i64x2.eq"; + break; case EqVecF32x4: o << "f32x4.eq"; break; @@ -1317,6 +1534,22 @@ case AvgrUVecI16x8: o << "i16x8.avgr_u"; break; + case Q15MulrSatSVecI16x8: + o << "i16x8.q15mulr_sat_s"; + break; + case ExtMulLowSVecI16x8: + o << "i16x8.extmul_low_i8x16_s"; + break; + case ExtMulHighSVecI16x8: + o << "i16x8.extmul_high_i8x16_s"; + break; + case ExtMulLowUVecI16x8: + o << "i16x8.extmul_low_i8x16_u"; + break; + case ExtMulHighUVecI16x8: + o << "i16x8.extmul_high_i8x16_u"; + break; + case AddVecI32x4: o << "i32x4.add"; break; @@ -1341,6 +1574,19 @@ case DotSVecI16x8ToVecI32x4: o << "i32x4.dot_i16x8_s"; break; + case ExtMulLowSVecI32x4: + o << "i32x4.extmul_low_i16x8_s"; + break; + case ExtMulHighSVecI32x4: + o << "i32x4.extmul_high_i16x8_s"; + break; + case ExtMulLowUVecI32x4: + o << "i32x4.extmul_low_i16x8_u"; + break; + case ExtMulHighUVecI32x4: + o << "i32x4.extmul_high_i16x8_u"; + break; + case AddVecI64x2: o << "i64x2.add"; break; @@ -1350,6 +1596,18 @@ case MulVecI64x2: o << "i64x2.mul"; break; + case ExtMulLowSVecI64x2: + o << "i64x2.extmul_low_i32x4_s"; + break; + case ExtMulHighSVecI64x2: + o << "i64x2.extmul_high_i32x4_s"; + break; + case ExtMulLowUVecI64x2: + o << "i64x2.extmul_low_i32x4_u"; + break; + case ExtMulHighUVecI64x2: + o << "i64x2.extmul_high_i32x4_u"; + break; case AddVecF32x4: o << "f32x4.add"; @@ -1425,7 +1683,7 @@ void visitSelect(Select* curr) { prepareColor(o) << "select"; if (curr->type.isRef()) { - o << " (result " << curr->type << ')'; + o << ' ' << ResultTypeName(curr->type); } } void visitDrop(Drop* curr) { printMedium(o, "drop"); } @@ -1434,7 +1692,7 @@ void visitMemoryGrow(MemoryGrow* curr) { printMedium(o, "memory.grow"); } void visitRefNull(RefNull* curr) { printMedium(o, "ref.null "); - o << curr->type.getHeapType(); + printHeapTypeName(o, curr->type.getHeapType()); } void visitRefIsNull(RefIsNull* curr) { printMedium(o, "ref.is_null"); } void visitRefFunc(RefFunc* curr) { @@ -1478,49 +1736,93 @@ void visitI31Get(I31Get* curr) { printMedium(o, curr->signed_ ? "i31.get_s" : "i31.get_u"); } + void visitCallRef(CallRef* curr) { + if (curr->isReturn) { + printMedium(o, "return_call_ref"); + } else { + printMedium(o, "call_ref"); + } + } void visitRefTest(RefTest* curr) { - printMedium(o, "ref.test"); - WASM_UNREACHABLE("TODO (gc): ref.test"); + printMedium(o, "ref.test "); + printHeapTypeName(o, curr->getCastType().getHeapType()); } void visitRefCast(RefCast* curr) { - printMedium(o, "ref.cast"); - WASM_UNREACHABLE("TODO (gc): ref.cast"); + printMedium(o, "ref.cast "); + printHeapTypeName(o, curr->getCastType().getHeapType()); } void visitBrOnCast(BrOnCast* curr) { - printMedium(o, "br_on_cast"); - WASM_UNREACHABLE("TODO (gc): br_on_cast"); + printMedium(o, "br_on_cast "); + printName(curr->name, o); + o << " "; + printHeapTypeName(o, curr->getCastType().getHeapType()); } void visitRttCanon(RttCanon* curr) { - printMedium(o, "rtt.canon"); - WASM_UNREACHABLE("TODO (gc): rtt.canon"); + printMedium(o, "rtt.canon "); + printHeapTypeName(o, curr->type.getRtt().heapType); } void visitRttSub(RttSub* curr) { - printMedium(o, "rtt.sub"); - WASM_UNREACHABLE("TODO (gc): rtt.sub"); + printMedium(o, "rtt.sub "); + printHeapTypeName(o, curr->type.getRtt().heapType); } void visitStructNew(StructNew* curr) { - WASM_UNREACHABLE("TODO (gc): struct.new"); + printMedium(o, "struct.new_"); + if (curr->isWithDefault()) { + o << "default_"; + } + o << "with_rtt "; + printHeapTypeName(o, curr->rtt->type.getHeapType()); } void visitStructGet(StructGet* curr) { - WASM_UNREACHABLE("TODO (gc): struct.get"); + const auto& field = + curr->ref->type.getHeapType().getStruct().fields[curr->index]; + if (field.type == Type::i32 && field.packedType != Field::not_packed) { + if (curr->signed_) { + printMedium(o, "struct.get_s "); + } else { + printMedium(o, "struct.get_u "); + } + } else { + printMedium(o, "struct.get "); + } + printHeapTypeName(o, curr->ref->type.getHeapType()); + o << ' '; + o << curr->index; } void visitStructSet(StructSet* curr) { - printMedium(o, "struct.set"); - WASM_UNREACHABLE("TODO (gc): struct.set"); + printMedium(o, "struct.set "); + printHeapTypeName(o, curr->ref->type.getHeapType()); + o << ' '; + o << curr->index; } void visitArrayNew(ArrayNew* curr) { - WASM_UNREACHABLE("TODO (gc): array.new"); + printMedium(o, "array.new_"); + if (curr->isWithDefault()) { + o << "default_"; + } + o << "with_rtt "; + printHeapTypeName(o, curr->rtt->type.getHeapType()); } void visitArrayGet(ArrayGet* curr) { - WASM_UNREACHABLE("TODO (gc): array.get"); + const auto& element = curr->ref->type.getHeapType().getArray().element; + if (element.type == Type::i32 && element.packedType != Field::not_packed) { + if (curr->signed_) { + printMedium(o, "array.get_s "); + } else { + printMedium(o, "array.get_u "); + } + } else { + printMedium(o, "array.get "); + } + printHeapTypeName(o, curr->ref->type.getHeapType()); } void visitArraySet(ArraySet* curr) { - printMedium(o, "array.set"); - WASM_UNREACHABLE("TODO (gc): array.set"); + printMedium(o, "array.set "); + printHeapTypeName(o, curr->ref->type.getHeapType()); } void visitArrayLen(ArrayLen* curr) { - printMedium(o, "array.len"); - WASM_UNREACHABLE("TODO (gc): array.len"); + printMedium(o, "array.len "); + printHeapTypeName(o, curr->ref->type.getHeapType()); } }; @@ -1536,9 +1838,9 @@ 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) + bool stackIR = 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; @@ -1598,7 +1900,7 @@ void setFull(bool full_) { full = full_; } - void setPrintStackIR(bool printStackIR_) { printStackIR = printStackIR_; } + void setStackIR(bool stackIR_) { stackIR = stackIR_; } void setDebugInfo(bool debugInfo_) { debugInfo = debugInfo_; } @@ -1908,6 +2210,21 @@ printFullLine(curr->ptr); decIndent(); } + void visitSIMDLoadStoreLane(SIMDLoadStoreLane* curr) { + o << '('; + PrintExpressionContents(currFunction, o).visit(curr); + incIndent(); + printFullLine(curr->ptr); + printFullLine(curr->vec); + decIndent(); + } + void visitPrefetch(Prefetch* curr) { + o << '('; + PrintExpressionContents(currFunction, o).visit(curr); + incIndent(); + printFullLine(curr->ptr); + decIndent(); + } void visitMemoryInit(MemoryInit* curr) { o << '('; PrintExpressionContents(currFunction, o).visit(curr); @@ -2125,82 +2442,186 @@ printFullLine(curr->i31); decIndent(); } + void visitCallRef(CallRef* curr) { + o << '('; + PrintExpressionContents(currFunction, o).visit(curr); + incIndent(); + for (auto operand : curr->operands) { + printFullLine(operand); + } + printFullLine(curr->target); + decIndent(); + } void visitRefTest(RefTest* curr) { o << '('; PrintExpressionContents(currFunction, o).visit(curr); - WASM_UNREACHABLE("TODO (gc): ref.test"); + incIndent(); + printFullLine(curr->ref); + printFullLine(curr->rtt); + decIndent(); } void visitRefCast(RefCast* curr) { o << '('; PrintExpressionContents(currFunction, o).visit(curr); - WASM_UNREACHABLE("TODO (gc): ref.cast"); + incIndent(); + printFullLine(curr->ref); + printFullLine(curr->rtt); + decIndent(); } void visitBrOnCast(BrOnCast* curr) { o << '('; PrintExpressionContents(currFunction, o).visit(curr); - WASM_UNREACHABLE("TODO (gc): br_on_cast"); + incIndent(); + printFullLine(curr->ref); + printFullLine(curr->rtt); + decIndent(); } void visitRttCanon(RttCanon* curr) { o << '('; PrintExpressionContents(currFunction, o).visit(curr); - WASM_UNREACHABLE("TODO (gc): rtt.canon"); + o << ')'; } void visitRttSub(RttSub* curr) { o << '('; PrintExpressionContents(currFunction, o).visit(curr); - WASM_UNREACHABLE("TODO (gc): rtt.sub"); + incIndent(); + printFullLine(curr->parent); + decIndent(); } void visitStructNew(StructNew* curr) { o << '('; PrintExpressionContents(currFunction, o).visit(curr); - WASM_UNREACHABLE("TODO (gc): struct.new"); + incIndent(); + printFullLine(curr->rtt); + for (auto& operand : curr->operands) { + printFullLine(operand); + } + decIndent(); } void visitStructGet(StructGet* curr) { o << '('; PrintExpressionContents(currFunction, o).visit(curr); - WASM_UNREACHABLE("TODO (gc): struct.get"); + incIndent(); + printFullLine(curr->ref); + decIndent(); } void visitStructSet(StructSet* curr) { o << '('; PrintExpressionContents(currFunction, o).visit(curr); - WASM_UNREACHABLE("TODO (gc): struct.set"); + incIndent(); + printFullLine(curr->ref); + printFullLine(curr->value); + decIndent(); } void visitArrayNew(ArrayNew* curr) { o << '('; PrintExpressionContents(currFunction, o).visit(curr); - WASM_UNREACHABLE("TODO (gc): array.new"); + incIndent(); + printFullLine(curr->rtt); + printFullLine(curr->size); + if (curr->init) { + printFullLine(curr->init); + } + decIndent(); } void visitArrayGet(ArrayGet* curr) { o << '('; PrintExpressionContents(currFunction, o).visit(curr); - WASM_UNREACHABLE("TODO (gc): array.get"); + incIndent(); + printFullLine(curr->ref); + printFullLine(curr->index); + decIndent(); } void visitArraySet(ArraySet* curr) { o << '('; PrintExpressionContents(currFunction, o).visit(curr); - WASM_UNREACHABLE("TODO (gc): array.set"); + incIndent(); + printFullLine(curr->ref); + printFullLine(curr->index); + printFullLine(curr->value); + decIndent(); } void visitArrayLen(ArrayLen* curr) { o << '('; PrintExpressionContents(currFunction, o).visit(curr); - WASM_UNREACHABLE("TODO (gc): array.len"); + incIndent(); + printFullLine(curr->ref); + decIndent(); } // Module-level visitors - void handleSignature(Signature curr, Name* funcName = nullptr) { + void handleSignature(Signature curr, Name name = Name()) { o << "(func"; - if (funcName) { - o << " $" << *funcName; + if (name.is()) { + o << " $" << name; } if (curr.params.size() > 0) { o << maybeSpace; - o << ParamType(curr.params); + o << "(param "; + auto sep = ""; + for (auto type : curr.params) { + o << sep << SExprType(type); + sep = " "; + } + o << ')'; } if (curr.results.size() > 0) { o << maybeSpace; - o << ResultType(curr.results); + o << "(result "; + auto sep = ""; + for (auto type : curr.results) { + o << sep << SExprType(type); + sep = " "; + } + o << ')'; } o << ")"; } + void handleFieldBody(const Field& field) { + if (field.mutable_) { + o << "(mut "; + } + if (field.type == Type::i32 && field.packedType != Field::not_packed) { + if (field.packedType == Field::i8) { + o << "i8"; + } else if (field.packedType == Field::i16) { + o << "i16"; + } else { + WASM_UNREACHABLE("invalid packed type"); + } + } else { + o << SExprType(field.type); + } + if (field.mutable_) { + o << ')'; + } + } + void handleArray(const Array& curr) { + o << "(array "; + handleFieldBody(curr.element); + o << ')'; + } + void handleStruct(const Struct& curr) { + o << "(struct "; + auto sep = ""; + for (auto field : curr.fields) { + o << sep << "(field "; + handleFieldBody(field); + o << ')'; + sep = " "; + } + o << ')'; + } + void handleHeapType(HeapType type) { + if (type.isSignature()) { + handleSignature(type.getSignature()); + } else if (type.isArray()) { + handleArray(type.getArray()); + } else if (type.isStruct()) { + handleStruct(type.getStruct()); + } else { + o << type; + } + } void visitExport(Export* curr) { o << '('; printMedium(o, "export "); @@ -2279,7 +2700,7 @@ lastPrintedLocation = {0, 0, 0}; o << '('; emitImportHeader(curr); - handleSignature(curr->sig, &curr->name); + handleSignature(curr->sig, curr->name); o << ')'; o << maybeNewLine; } @@ -2293,7 +2714,7 @@ o << '('; printMajor(o, "func "); printName(curr->name, o); - if (!printStackIR && curr->stackIR && !minify) { + if (!stackIR && curr->stackIR && !minify) { o << " (; has Stack IR ;)"; } if (curr->sig.params.size() > 0) { @@ -2303,13 +2724,13 @@ o << '('; printMinor(o, "param "); printLocal(i, currFunction, o); - o << ' ' << param << ')'; + o << ' ' << SExprType(param) << ')'; ++i; } } if (curr->sig.results != Type::none) { o << maybeSpace; - o << ResultType(curr->sig.results); + o << ResultTypeName(curr->sig.results); } incIndent(); for (size_t i = curr->getVarIndexBase(); i < curr->getNumLocals(); i++) { @@ -2321,7 +2742,7 @@ o << maybeNewLine; } // Print the body. - if (!printStackIR || !curr->stackIR) { + if (!stackIR || !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.. @@ -2336,7 +2757,7 @@ } } else { // Print the stack IR. - WasmPrinter::printStackIR(curr->stackIR.get(), o, curr); + printStackIR(curr->stackIR.get(), o, curr); } if (currFunction->epilogLocation.size() && lastPrintedLocation != *currFunction->epilogLocation.begin()) { @@ -2460,6 +2881,10 @@ doIndent(o, indent); o << '('; printMajor(o, "data "); + if (segment.name.is()) { + printName(segment.name, o); + o << ' '; + } if (segment.isPassive) { printMedium(o, "passive"); } else { @@ -2528,15 +2953,16 @@ printName(curr->name, o); } incIndent(); - std::vector signatures; - std::unordered_map indices; - ModuleUtils::collectSignatures(*curr, signatures, indices); - for (auto sig : signatures) { + std::vector types; + std::unordered_map indices; + ModuleUtils::collectHeapTypes(*curr, types, indices); + for (auto type : types) { doIndent(o, indent); o << '('; printMedium(o, "type") << ' '; - o << SigName(sig) << ' '; - handleSignature(sig); + printHeapTypeName(o, type); + o << ' '; + handleHeapType(type); o << ")" << maybeNewLine; } ModuleUtils::iterImportedMemories( @@ -2669,29 +3095,17 @@ void run(PassRunner* runner, Module* module) override { PrintSExpression print(o); print.setDebugInfo(runner->options.debugInfo); - print.setPrintStackIR(true); + print.setStackIR(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) { +static std::ostream& printExpression(Expression* expression, + std::ostream& o, + bool minify, + bool full) { if (!expression) { o << "(null expression)"; return o; @@ -2706,8 +3120,8 @@ return o; } -std::ostream& -WasmPrinter::printStackInst(StackInst* inst, std::ostream& o, Function* func) { +static std::ostream& +printStackInst(StackInst* inst, std::ostream& o, Function* func) { switch (inst->op) { case StackInst::Basic: { PrintExpressionContents(func, o).visit(inst->origin); @@ -2741,8 +3155,8 @@ return o; } -std::ostream& -WasmPrinter::printStackIR(StackIR* ir, std::ostream& o, Function* func) { +static std::ostream& +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++) { @@ -2806,3 +3220,29 @@ } } // namespace wasm + +namespace std { + +std::ostream& operator<<(std::ostream& o, wasm::Module& module) { + wasm::PassRunner runner(&module); + wasm::Printer(&o).run(&runner, &module); + return o; +} + +std::ostream& operator<<(std::ostream& o, wasm::Expression& expression) { + return wasm::printExpression(&expression, o); +} + +std::ostream& operator<<(std::ostream& o, wasm::Expression* expression) { + return wasm::printExpression(expression, o); +} + +std::ostream& operator<<(std::ostream& o, wasm::StackInst& inst) { + return wasm::printStackInst(&inst, o); +} + +std::ostream& operator<<(std::ostream& o, wasm::StackIR& ir) { + return wasm::printStackIR(&ir, o); +} + +} // namespace std diff --git a/binaryen/src/passes/ReReloop.cpp b/binaryen/src/passes/ReReloop.cpp --- a/binaryen/src/passes/ReReloop.cpp +++ b/binaryen/src/passes/ReReloop.cpp @@ -31,10 +31,6 @@ #include "wasm-traversal.h" #include "wasm.h" -#ifdef RERELOOP_DEBUG -#include -#endif - namespace wasm { struct ReReloop final : public Pass { @@ -362,7 +358,7 @@ } } // TODO: should this be in the relooper itself? - ReFinalize().walk(function->body); + ReFinalize().walkFunctionInModule(function, module); } }; diff --git a/binaryen/src/passes/RemoveNonJSOps.cpp b/binaryen/src/passes/RemoveNonJSOps.cpp --- a/binaryen/src/passes/RemoveNonJSOps.cpp +++ b/binaryen/src/passes/RemoveNonJSOps.cpp @@ -299,13 +299,6 @@ 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; diff --git a/binaryen/src/passes/RemoveUnusedBrs.cpp b/binaryen/src/passes/RemoveUnusedBrs.cpp --- a/binaryen/src/passes/RemoveUnusedBrs.cpp +++ b/binaryen/src/passes/RemoveUnusedBrs.cpp @@ -930,6 +930,17 @@ !iff->ifFalse->type.isSingle()) { return nullptr; } + if (iff->condition->type == Type::unreachable) { + // An if with an unreachable condition may nonetheless have a type + // that is not unreachable, + // + // (if (result i32) (unreachable) ..) + // + // Turning such an if into a select would change the type of the + // expression, which would require updating types further up. Avoid + // that, leaving dead code elimination to that dedicated pass. + 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. @@ -937,20 +948,23 @@ passOptions, iff->ifTrue, iff->ifFalse)) { return nullptr; } - // Check if side effects allow this. + // Check if side effects allow this: we need to execute the two arms + // unconditionally, and also to make the condition run last. FeatureSet features = getModule()->features; + EffectAnalyzer ifTrue(passOptions, features, iff->ifTrue); + if (ifTrue.hasSideEffects()) { + return nullptr; + } + EffectAnalyzer ifFalse(passOptions, features, iff->ifFalse); + if (ifFalse.hasSideEffects()) { + return nullptr; + } 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); - } - } + if (condition.invalidates(ifTrue) || condition.invalidates(ifFalse)) { + return nullptr; } - return nullptr; + return Builder(*getModule()) + .makeSelect(iff->condition, iff->ifTrue, iff->ifFalse); } void visitLocalSet(LocalSet* curr) { diff --git a/binaryen/src/passes/RemoveUnusedModuleElements.cpp b/binaryen/src/passes/RemoveUnusedModuleElements.cpp --- a/binaryen/src/passes/RemoveUnusedModuleElements.cpp +++ b/binaryen/src/passes/RemoveUnusedModuleElements.cpp @@ -22,7 +22,6 @@ #include -#include "asm_v_wasm.h" #include "ir/module-utils.h" #include "ir/utils.h" #include "pass.h" diff --git a/binaryen/src/passes/RemoveUnusedNames.cpp b/binaryen/src/passes/RemoveUnusedNames.cpp --- a/binaryen/src/passes/RemoveUnusedNames.cpp +++ b/binaryen/src/passes/RemoveUnusedNames.cpp @@ -19,12 +19,15 @@ // merge names when possible (by merging their blocks) // +#include #include #include namespace wasm { -struct RemoveUnusedNames : public WalkerPass> { +struct RemoveUnusedNames + : public WalkerPass>> { bool isFunctionParallel() override { return true; } Pass* create() override { return new RemoveUnusedNames; } @@ -33,17 +36,19 @@ // 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); + void visitExpression(Expression* curr) { + if (auto* block = curr->dynCast()) { + visitBlock(block); + return; } - branchesSeen[curr->default_].insert(curr); + if (auto* loop = curr->dynCast()) { + visitLoop(loop); + return; + } + BranchUtils::operateOnScopeNameUses( + curr, [&](Name& name) { branchesSeen[name].insert(curr); }); } - void visitBrOnExn(BrOnExn* curr) { branchesSeen[curr->name].insert(curr); } - void handleBreakTarget(Name& name) { if (name.is()) { if (branchesSeen.find(name) == branchesSeen.end()) { @@ -62,26 +67,7 @@ // 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"); - } + BranchUtils::replacePossibleTarget(branch, curr->name, child->name); } child->finalize(child->type); replaceCurrent(child); diff --git a/binaryen/src/passes/ReplaceStackPointer.cpp b/binaryen/src/passes/ReplaceStackPointer.cpp deleted file mode 100644 --- a/binaryen/src/passes/ReplaceStackPointer.cpp +++ /dev/null @@ -1,103 +0,0 @@ -/* - * 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/SafeHeap.cpp b/binaryen/src/passes/SafeHeap.cpp --- a/binaryen/src/passes/SafeHeap.cpp +++ b/binaryen/src/passes/SafeHeap.cpp @@ -20,7 +20,6 @@ // 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" @@ -31,7 +30,6 @@ 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"); @@ -68,6 +66,10 @@ // 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. + // As well as the getSbrkPtr function we also avoid instrumenting the + // module start function. This is because this function is used in + // shared memory builds to load the passive memory segments, which in + // turn means that value of sbrk() is not available. Name getSbrkPtr; bool isFunctionParallel() override { return true; } @@ -79,7 +81,12 @@ AccessInstrumenter(Name getSbrkPtr) : getSbrkPtr(getSbrkPtr) {} void visitLoad(Load* curr) { - if (getFunction()->name == getSbrkPtr || curr->type == Type::unreachable) { + // As well as the getSbrkPtr function we also avoid insturmenting the + // module start function. This is because this function is used in + // shared memory builds to load the passive memory segments, which in + // turn means that value of sbrk() is not available. + if (getFunction()->name == getModule()->start || + getFunction()->name == getSbrkPtr || curr->type == Type::unreachable) { return; } Builder builder(*getModule()); @@ -90,7 +97,8 @@ } void visitStore(Store* curr) { - if (getFunction()->name == getSbrkPtr || curr->type == Type::unreachable) { + if (getFunction()->name == getModule()->start || + getFunction()->name == getSbrkPtr || curr->type == Type::unreachable) { return; } Builder builder(*getModule()); @@ -119,11 +127,7 @@ 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)) { + if (auto* existing = info.getImportedFunction(ENV, GET_SBRK_PTR)) { getSbrkPtr = existing->name; } else if (auto* existing = module->getExportOrNull(GET_SBRK_PTR)) { getSbrkPtr = existing->value; diff --git a/binaryen/src/passes/SimplifyLocals.cpp b/binaryen/src/passes/SimplifyLocals.cpp --- a/binaryen/src/passes/SimplifyLocals.cpp +++ b/binaryen/src/passes/SimplifyLocals.cpp @@ -964,16 +964,23 @@ } anotherCycle = true; } + // Nothing more to do, ignore the copy. + return; } else if (func->getLocalType(curr->index) == func->getLocalType(get->index)) { - // There is a new equivalence now. + // There is a new equivalence now. Remove all the old ones, and add + // the new one. + // Note that we ignore the case of subtyping here, to keep this + // optimization simple by assuming all equivalent indexes also have + // the same type. TODO: consider optimizing this. equivalences.reset(curr->index); equivalences.add(curr->index, get->index); + return; } - } else { - // A new value is assigned here. - equivalences.reset(curr->index); } + // A new value of some kind is assigned here, and it's not something we + // could handle earlier, so remove all the old equivalent ones. + equivalences.reset(curr->index); } void visitLocalGet(LocalGet* curr) { diff --git a/binaryen/src/passes/Souperify.cpp b/binaryen/src/passes/Souperify.cpp --- a/binaryen/src/passes/Souperify.cpp +++ b/binaryen/src/passes/Souperify.cpp @@ -464,8 +464,7 @@ case Node::Type::Expr: { if (debug()) { std::cout << "; "; - WasmPrinter::printExpression(node->expr, std::cout, true); - std::cout << '\n'; + std::cout << *node->expr << '\n'; } std::cout << "%" << indexing[node] << " = "; printExpression(node); diff --git a/binaryen/src/passes/SpillPointers.cpp b/binaryen/src/passes/SpillPointers.cpp deleted file mode 100644 --- a/binaryen/src/passes/SpillPointers.cpp +++ /dev/null @@ -1,206 +0,0 @@ -/* - * 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 --- a/binaryen/src/passes/StackCheck.cpp +++ b/binaryen/src/passes/StackCheck.cpp @@ -22,6 +22,7 @@ #include "abi/js.h" #include "ir/import-utils.h" +#include "ir/names.h" #include "pass.h" #include "shared-constants.h" #include "support/debug.h" @@ -31,11 +32,6 @@ 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"); @@ -52,30 +48,18 @@ } } -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); +static void addExportedFunction(Module& module, + std::unique_ptr function) { + auto export_ = + Builder::makeExport(function->name, function->name, ExternalKind::Function); + module.addFunction(std::move(function)); + module.addExport(std::move(export_)); } struct EnforceStackLimits : public WalkerPass> { - EnforceStackLimits(Global* stackPointer, - Global* stackBase, - Global* stackLimit, + EnforceStackLimits(const Global* stackPointer, + const Global* stackBase, + const Global* stackLimit, Builder& builder, Name handler) : stackPointer(stackPointer), stackBase(stackBase), stackLimit(stackLimit), @@ -127,9 +111,9 @@ } private: - Global* stackPointer; - Global* stackBase; - Global* stackLimit; + const Global* stackPointer; + const Global* stackBase; + const Global* stackLimit; Builder& builder; Name handler; }; @@ -142,6 +126,10 @@ return; } + // Pick appropriate names. + auto stackBaseName = Names::getValidGlobalName(*module, "__stack_base"); + auto stackLimitName = Names::getValidGlobalName(*module, "__stack_limit"); + Name handler; auto handlerName = runner->options.getArgumentOrDefault("stack-check-handler", ""); @@ -151,22 +139,33 @@ } Builder builder(*module); - Global* stackBase = builder.makeGlobal(STACK_BASE, + + // Add the globals. + auto stackBase = + module->addGlobal(builder.makeGlobal(stackBaseName, 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); + Builder::Mutable)); + auto stackLimit = + module->addGlobal(builder.makeGlobal(stackLimitName, + stackPointer->type, + builder.makeConst(int32_t(0)), + Builder::Mutable)); + // Instrument all the code. PassRunner innerRunner(module); EnforceStackLimits(stackPointer, stackBase, stackLimit, builder, handler) .run(&innerRunner, module); - generateSetStackLimitFunctions(*module); + + // Generate the exported function. + auto limitsFunc = builder.makeFunction( + SET_STACK_LIMITS, Signature({Type::i32, Type::i32}, Type::none), {}); + auto* getBase = builder.makeLocalGet(0, Type::i32); + auto* storeBase = builder.makeGlobalSet(stackBaseName, getBase); + auto* getLimit = builder.makeLocalGet(1, Type::i32); + auto* storeLimit = builder.makeGlobalSet(stackLimitName, getLimit); + limitsFunc->body = builder.makeBlock({storeBase, storeLimit}); + addExportedFunction(*module, std::move(limitsFunc)); } }; diff --git a/binaryen/src/passes/TrapMode.cpp b/binaryen/src/passes/TrapMode.cpp --- a/binaryen/src/passes/TrapMode.cpp +++ b/binaryen/src/passes/TrapMode.cpp @@ -20,14 +20,12 @@ // 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" @@ -37,6 +35,18 @@ Name I64U_REM("i64u-rem"); Name I64S_DIV("i64s-div"); Name I64U_DIV("i64u-div"); + +static 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; +} Name getBinaryFuncName(Binary* curr) { switch (curr->op) { diff --git a/binaryen/src/passes/Vacuum.cpp b/binaryen/src/passes/Vacuum.cpp --- a/binaryen/src/passes/Vacuum.cpp +++ b/binaryen/src/passes/Vacuum.cpp @@ -20,6 +20,7 @@ #include #include +#include #include #include #include @@ -49,169 +50,85 @@ 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: + // Returns nullptr if curr is dead, curr if it must stay as is, or one of its + // children 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). + // * The type may or may not matter. + // + // For example, + // + // (drop + // (i32.eqz + // (call ..))) + // + // The drop means that the value is not used later. And while the call has + // side effects, the i32.eqz does not. So when we are called on the i32.eqz, + // and told the result does not matter, we can return the call. Note that in + // this case the type does not matter either, as drop doesn't care, and anyhow + // i32.eqz returns the same type as it receives. But for an expression that + // returns a different type, if the type matters then we cannot replace it. Expression* optimize(Expression* curr, bool resultUsed, bool typeMatters) { FeatureSet features = getModule()->features; auto type = curr->type; - // An unreachable node must not be changed. + // If the type is none, then we can never replace it with another type. + if (type == Type::none) { + typeMatters = true; + } + // An unreachable node must not be changed. DCE will remove those. if (type == Type::unreachable) { return curr; } - // We iterate on possible replacements. If a replacement changes the type, - // stop and go back. + // resultUsed only makes sense when the type is concrete + assert(!resultUsed || curr->type != Type::none); + // If we actually need the result, then we must not change anything. + // TODO: maybe there is something clever though? + if (resultUsed) { + return curr; + } + // We iterate on possible replacements. auto* prev = curr; while (1) { + // If a replacement changes the type, and the type matters, return the + // previous one and stop. 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()); - } - static void doVisitDrop(SubType* self, Expression** currp) { - self->visitDrop((*currp)->cast()); - } - static void doVisitReturn(SubType* self, Expression** currp) { - self->visitReturn((*currp)->cast()); - } - static void doVisitMemorySize(SubType* self, Expression** currp) { - self->visitMemorySize((*currp)->cast()); - } - static void doVisitMemoryGrow(SubType* self, Expression** currp) { - self->visitMemoryGrow((*currp)->cast()); - } - static void doVisitRefNull(SubType* self, Expression** currp) { - self->visitRefNull((*currp)->cast()); - } - static void doVisitRefIsNull(SubType* self, Expression** currp) { - self->visitRefIsNull((*currp)->cast()); - } - static void doVisitRefFunc(SubType* self, Expression** currp) { - self->visitRefFunc((*currp)->cast()); - } - static void doVisitRefEq(SubType* self, Expression** currp) { - self->visitRefEq((*currp)->cast()); - } - static void doVisitTry(SubType* self, Expression** currp) { - self->visitTry((*currp)->cast()); - } - static void doVisitThrow(SubType* self, Expression** currp) { - self->visitThrow((*currp)->cast()); - } - static void doVisitRethrow(SubType* self, Expression** currp) { - self->visitRethrow((*currp)->cast()); - } - static void doVisitBrOnExn(SubType* self, Expression** currp) { - self->visitBrOnExn((*currp)->cast()); - } - static void doVisitNop(SubType* self, Expression** currp) { - self->visitNop((*currp)->cast()); - } - static void doVisitUnreachable(SubType* self, Expression** currp) { - self->visitUnreachable((*currp)->cast()); - } - static void doVisitPop(SubType* self, Expression** currp) { - self->visitPop((*currp)->cast()); - } - static void doVisitTupleMake(SubType* self, Expression** currp) { - self->visitTupleMake((*currp)->cast()); - } - static void doVisitTupleExtract(SubType* self, Expression** currp) { - self->visitTupleExtract((*currp)->cast()); - } - static void doVisitI31New(SubType* self, Expression** currp) { - self->visitI31New((*currp)->cast()); - } - static void doVisitI31Get(SubType* self, Expression** currp) { - self->visitI31Get((*currp)->cast()); - } - static void doVisitRefTest(SubType* self, Expression** currp) { - self->visitRefTest((*currp)->cast()); - } - static void doVisitRefCast(SubType* self, Expression** currp) { - self->visitRefCast((*currp)->cast()); - } - static void doVisitBrOnCast(SubType* self, Expression** currp) { - self->visitBrOnCast((*currp)->cast()); - } - static void doVisitRttCanon(SubType* self, Expression** currp) { - self->visitRttCanon((*currp)->cast()); - } - static void doVisitRttSub(SubType* self, Expression** currp) { - self->visitRttSub((*currp)->cast()); - } - static void doVisitStructNew(SubType* self, Expression** currp) { - self->visitStructNew((*currp)->cast()); - } - static void doVisitStructGet(SubType* self, Expression** currp) { - self->visitStructGet((*currp)->cast()); - } - static void doVisitStructSet(SubType* self, Expression** currp) { - self->visitStructSet((*currp)->cast()); - } - static void doVisitArrayNew(SubType* self, Expression** currp) { - self->visitArrayNew((*currp)->cast()); - } - static void doVisitArrayGet(SubType* self, Expression** currp) { - self->visitArrayGet((*currp)->cast()); - } - static void doVisitArraySet(SubType* self, Expression** currp) { - self->visitArraySet((*currp)->cast()); - } - static void doVisitArrayLen(SubType* self, Expression** currp) { - self->visitArrayLen((*currp)->cast()); - } - - void setModule(Module* module) { currModule = module; } - - void setFunction(Function* func) { currFunction = func; } - -private: - // the address of the current node, used to replace it - Expression** replacep = nullptr; - SmallVector stack; // stack of tasks - Function* currFunction = nullptr; // current function being processed - Module* currModule = nullptr; // current module being processed -}; - -// Walks in post-order, i.e., children first. When there isn't an obvious -// order to operands, we follow them in order of execution. - -template> -struct PostWalker : public Walker { - - 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); - 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->maybePushTask(SubType::scan, &curr->cast()->ifFalse); - self->pushTask(SubType::scan, &curr->cast()->ifTrue); - self->pushTask(SubType::scan, &curr->cast()->condition); - break; - } - case Expression::Id::LoopId: { - self->pushTask(SubType::doVisitLoop, currp); - self->pushTask(SubType::scan, &curr->cast()->body); - break; - } - case Expression::Id::BreakId: { - self->pushTask(SubType::doVisitBreak, 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::scan, &curr->cast()->condition); - self->maybePushTask(SubType::scan, &curr->cast()->value); - break; - } - case Expression::Id::CallId: { - self->pushTask(SubType::doVisitCall, 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::CallIndirectId: { - self->pushTask(SubType::doVisitCallIndirect, currp); - auto& list = curr->cast()->operands; - self->pushTask(SubType::scan, &curr->cast()->target); - for (int i = int(list.size()) - 1; i >= 0; i--) { - self->pushTask(SubType::scan, &list[i]); - } - break; - } - case Expression::Id::LocalGetId: { - // TODO: optimize leaves with a direct call? - self->pushTask(SubType::doVisitLocalGet, currp); - break; - } - case Expression::Id::LocalSetId: { - self->pushTask(SubType::doVisitLocalSet, currp); - self->pushTask(SubType::scan, &curr->cast()->value); - break; - } - case Expression::Id::GlobalGetId: { - self->pushTask(SubType::doVisitGlobalGet, currp); - break; - } - case Expression::Id::GlobalSetId: { - self->pushTask(SubType::doVisitGlobalSet, currp); - self->pushTask(SubType::scan, &curr->cast()->value); - break; - } - case Expression::Id::LoadId: { - self->pushTask(SubType::doVisitLoad, currp); - self->pushTask(SubType::scan, &curr->cast()->ptr); - break; - } - case Expression::Id::StoreId: { - self->pushTask(SubType::doVisitStore, currp); - self->pushTask(SubType::scan, &curr->cast()->value); - self->pushTask(SubType::scan, &curr->cast()->ptr); - break; - } - case Expression::Id::AtomicRMWId: { - self->pushTask(SubType::doVisitAtomicRMW, currp); - self->pushTask(SubType::scan, &curr->cast()->value); - self->pushTask(SubType::scan, &curr->cast()->ptr); - break; - } - case Expression::Id::AtomicCmpxchgId: { - self->pushTask(SubType::doVisitAtomicCmpxchg, currp); - self->pushTask(SubType::scan, - &curr->cast()->replacement); - self->pushTask(SubType::scan, &curr->cast()->expected); - self->pushTask(SubType::scan, &curr->cast()->ptr); - break; - } - case Expression::Id::AtomicWaitId: { - self->pushTask(SubType::doVisitAtomicWait, currp); - self->pushTask(SubType::scan, &curr->cast()->timeout); - self->pushTask(SubType::scan, &curr->cast()->expected); - self->pushTask(SubType::scan, &curr->cast()->ptr); - break; - } - case Expression::Id::AtomicNotifyId: { - self->pushTask(SubType::doVisitAtomicNotify, currp); - self->pushTask(SubType::scan, &curr->cast()->notifyCount); - self->pushTask(SubType::scan, &curr->cast()->ptr); - break; - } - case Expression::Id::AtomicFenceId: { - self->pushTask(SubType::doVisitAtomicFence, currp); - break; - } - case Expression::Id::SIMDExtractId: { - self->pushTask(SubType::doVisitSIMDExtract, currp); - self->pushTask(SubType::scan, &curr->cast()->vec); - break; - } - case Expression::Id::SIMDReplaceId: { - self->pushTask(SubType::doVisitSIMDReplace, currp); - self->pushTask(SubType::scan, &curr->cast()->value); - self->pushTask(SubType::scan, &curr->cast()->vec); - break; - } - case Expression::Id::SIMDShuffleId: { - self->pushTask(SubType::doVisitSIMDShuffle, currp); - self->pushTask(SubType::scan, &curr->cast()->right); - self->pushTask(SubType::scan, &curr->cast()->left); - break; - } - case Expression::Id::SIMDTernaryId: { - self->pushTask(SubType::doVisitSIMDTernary, currp); - self->pushTask(SubType::scan, &curr->cast()->c); - self->pushTask(SubType::scan, &curr->cast()->b); - self->pushTask(SubType::scan, &curr->cast()->a); - break; - } - case Expression::Id::SIMDShiftId: { - self->pushTask(SubType::doVisitSIMDShift, currp); - self->pushTask(SubType::scan, &curr->cast()->shift); - self->pushTask(SubType::scan, &curr->cast()->vec); - break; - } - case Expression::Id::SIMDLoadId: { - self->pushTask(SubType::doVisitSIMDLoad, currp); - self->pushTask(SubType::scan, &curr->cast()->ptr); - break; - } - case Expression::Id::MemoryInitId: { - self->pushTask(SubType::doVisitMemoryInit, currp); - self->pushTask(SubType::scan, &curr->cast()->size); - self->pushTask(SubType::scan, &curr->cast()->offset); - self->pushTask(SubType::scan, &curr->cast()->dest); - break; - } - case Expression::Id::DataDropId: { - self->pushTask(SubType::doVisitDataDrop, currp); - break; - } - case Expression::Id::MemoryCopyId: { - self->pushTask(SubType::doVisitMemoryCopy, currp); - self->pushTask(SubType::scan, &curr->cast()->size); - self->pushTask(SubType::scan, &curr->cast()->source); - self->pushTask(SubType::scan, &curr->cast()->dest); - break; - } - case Expression::Id::MemoryFillId: { - self->pushTask(SubType::doVisitMemoryFill, currp); - self->pushTask(SubType::scan, &curr->cast()->size); - self->pushTask(SubType::scan, &curr->cast()->value); - self->pushTask(SubType::scan, &curr->cast()->dest); - break; - } - case Expression::Id::ConstId: { - self->pushTask(SubType::doVisitConst, currp); - break; - } - case Expression::Id::UnaryId: { - self->pushTask(SubType::doVisitUnary, currp); - self->pushTask(SubType::scan, &curr->cast()->value); - break; - } - case Expression::Id::BinaryId: { - self->pushTask(SubType::doVisitBinary, currp); - self->pushTask(SubType::scan, &curr->cast()->right); - self->pushTask(SubType::scan, &curr->cast()->left); - break; - } - case Expression::Id::SelectId: { - self->pushTask(SubType::doVisitSelect, currp); - self->pushTask(SubType::scan, &curr->cast()->ifFalse); - self->pushTask(SubType::scan, &curr->cast